atris 3.34.0 → 3.36.0

package/lib/task-db.js

@@ -27,6 +27,7 @@ const path = require('path');
 const os = require('os');
 const crypto = require('crypto');
 const { DatabaseSync } = require('node:sqlite');
+const reviewIntegrity = require('./review-integrity');
 
 const DEFAULT_DB_PATH = path.join(os.homedir(), '.atris', 'tasks.db');
 const TASK_EPISODES_FILE = path.join('.atris', 'state', 'task_episodes.jsonl');
@@ -108,7 +109,10 @@ function appendTaskCompletionLogs(db, row, { status, actor, action, proof } = {}
   const metadata = row.metadata && typeof row.metadata === 'object' ? row.metadata : {};
   const proofText = compactLogText(proof || metadata.latest_agent_proof || metadata.verify || '', 500);
   const member = existingMemberSlug(row.workspace_root, row, actor);
-  const title = status === 'failed' ? 'Task failed' : action === 'accepted' ? 'Task accepted' : 'Task completed';
+  const title = status === 'archived' ? 'Task archived'
+    : status === 'failed' ? 'Task failed'
+    : action === 'accepted' ? 'Task accepted'
+    : 'Task completed';
   const fields = {
     task: ref,
     title: row.title,
@@ -236,22 +240,43 @@ function newId() {
   return head + tail;
 }
 
-// Walk up from `start` to find the canonical workspace root. We check for
-// .git, then atris/, then .atris/. If none found, fall back to `start`. This
-// makes `atris task add` from a subdirectory write the same workspace_root
-// as parseTodo() reads from the project's atris/TODO.md.
+// Resolve the canonical workspace root so `atris task` from any subdirectory
+// keys the SAME store as the repo root. Precedence (nearest ancestor wins per
+// pass):
+//   1. A deliberate workspace spine — .atris/business.json (a bound customer
+//      sub-workspace) or atris/atris.md (the framework protocol file). These are
+//      intentional nested workspaces INSIDE a repo and must stay isolated.
+//   2. The git toplevel (.git). One git repo == one workspace; this rescues a
+//      subdirectory whose only markers are a bare atris/ or .atris/ dir.
+//   3. Legacy fallback for non-git trees: a bare atris/ or .atris/ dir.
+//
+// Before this, a bare atris/ or .atris/ dir short-circuited ahead of the git
+// root, so a subdir like backend/ (which has an atris/ folder plus a stray
+// .atris) hijacked itself as a second workspace root and split task/usage state
+// into backend/.atris (proven footgun 2026-07-16). Checking .git only at the
+// same level meant the walk returned before ever reaching the real repo root.
 function findWorkspaceRoot(start) {
-  let cur = path.resolve(start || process.cwd());
-  // Cap the walk at 32 levels to avoid pathological symlink loops.
-  for (let i = 0; i < 32; i++) {
-    if (fs.existsSync(path.join(cur, '.git'))) return cur;
-    if (fs.existsSync(path.join(cur, 'atris'))) return cur;
-    if (fs.existsSync(path.join(cur, '.atris'))) return cur;
-    const parent = path.dirname(cur);
-    if (parent === cur) break;
-    cur = parent;
-  }
-  return path.resolve(start || process.cwd());
+  const origin = path.resolve(start || process.cwd());
+  // Cap each walk at 32 levels to avoid pathological symlink loops.
+  const walkUp = (test) => {
+    let cur = origin;
+    for (let i = 0; i < 32; i++) {
+      if (test(cur)) return cur;
+      const parent = path.dirname(cur);
+      if (parent === cur) break;
+      cur = parent;
+    }
+    return null;
+  };
+  const spine = walkUp((dir) => fs.existsSync(path.join(dir, '.atris', 'business.json'))
+    || fs.existsSync(path.join(dir, 'atris', 'atris.md')));
+  if (spine) return spine;
+  const gitRoot = walkUp((dir) => fs.existsSync(path.join(dir, '.git')));
+  if (gitRoot) return gitRoot;
+  const legacy = walkUp((dir) => fs.existsSync(path.join(dir, 'atris'))
+    || fs.existsSync(path.join(dir, '.atris')));
+  if (legacy) return legacy;
+  return origin;
 }
 
 function workspaceRoot(cwd) {
@@ -413,7 +438,7 @@ function listTasks(db, { workspaceRoot: ws, status, claimedBy, limit }) {
     FROM tasks
     ${where.length ? 'WHERE ' + where.join(' AND ') : ''}
     ORDER BY
-      CASE status WHEN 'open' THEN 0 WHEN 'claimed' THEN 1 WHEN 'review' THEN 2 WHEN 'failed' THEN 3 WHEN 'done' THEN 4 ELSE 5 END,
+      CASE status WHEN 'open' THEN 0 WHEN 'claimed' THEN 1 WHEN 'review' THEN 2 WHEN 'failed' THEN 3 WHEN 'done' THEN 4 WHEN 'archived' THEN 5 ELSE 6 END,
       CASE WHEN tag='endgame' THEN 0 ELSE 1 END,
       created_at DESC
     ${limit ? 'LIMIT ' + Number(limit) : ''}
@@ -506,10 +531,13 @@ function releaseTask(db, { id, actor }) {
   return { released: true, row: updated, event };
 }
 
-function doneTask(db, { id, status, actor, allowReview = false, action, proof } = {}) {
+function doneTask(db, { id, status, actor, allowReview = false, action, proof, autoAccepted = false } = {}) {
   if (!id) throw new Error('id required');
   const final = status || 'done';
   if (!['done', 'failed'].includes(final)) throw new Error('status must be done|failed');
+  // 'archived' is a distinct terminal status written by archiveTask(), never
+  // by this function — a bulk sweep of duplicate/off-roadmap tasks must not
+  // read as a real failure. See archiveTask() below.
   const now = Date.now();
   const allowedStatuses = allowReview ? "'open', 'claimed', 'review'" : "'open', 'claimed'";
   const result = withBusyRetry(() => db.prepare(`
@@ -525,7 +553,11 @@ function doneTask(db, { id, status, actor, allowReview = false, action, proof }
       workspaceRoot: row.workspace_root,
       actor: actor || process.env.ATRIS_AGENT_ID || process.env.USER || null,
       eventType: final === 'done' ? 'completed' : 'blocked',
-      payload: { status: final, action: action || final },
+      payload: {
+        status: final,
+        action: action || final,
+        ...(autoAccepted ? { auto_accepted: true } : {}),
+      },
     });
     const logs = appendTaskCompletionLogs(db, row, {
       status: final,
@@ -538,12 +570,147 @@ function doneTask(db, { id, status, actor, allowReview = false, action, proof }
   return { updated: false };
 }
 
+// Distinct terminal status for housekeeping sweeps (duplicate loop-ticks,
+// off-roadmap backlog resets, synthetic-test cleanup). Never conflate this
+// with `failed` — 'failed' means the work itself did not succeed, 'archived'
+// means the work was swept off the board for reasons unrelated to whether it
+// succeeded. Reward/RSI signal readers must treat the two differently.
+// `fromFailed: true` is an explicit opt-in for sanctioned historical cleanup
+// (e.g. the 109 duplicate "Loop tick:" orphans fail-closed before 'archived'
+// existed — cluster 1 of failed-tasks-analysis-2026-07-03). It permits the
+// failed→archived transition and records the prior status in
+// metadata.archived_from. Individual archive commands never archive 'done'
+// rows. The clear-done sweep opts in through fromDone after selecting only the
+// same 'done' rows counted by `atris status`.
+function archiveTask(db, { id, actor, reason, fromFailed = false, fromDone = false } = {}) {
+  if (!id) throw new Error('id required');
+  const reasonText = String(reason || '').trim();
+  if (!reasonText) throw new Error('reason required');
+  const row = getTask(db, id);
+  if (!row) return { archived: false, reason: 'not_found' };
+  const allowedStatuses = ['open', 'claimed', 'review'];
+  if (fromFailed) allowedStatuses.push('failed');
+  if (fromDone) allowedStatuses.push('done');
+  if (!allowedStatuses.includes(row.status)) {
+    return { archived: false, reason: `already_${row.status}` };
+  }
+  const now = Date.now();
+  const metadata = row.metadata && typeof row.metadata === 'object' ? { ...row.metadata } : {};
+  metadata.archived_reason = reasonText;
+  metadata.archived_at = new Date(now).toISOString();
+  metadata.archived_by = actor || process.env.ATRIS_AGENT_ID || process.env.USER || null;
+  metadata.approval_status = 'archived';
+  if (row.status === 'failed' || row.status === 'done') metadata.archived_from = row.status;
+  const terminalAt = row.status === 'done' && row.done_at ? row.done_at : now;
+  const statusPlaceholders = allowedStatuses.map(() => '?').join(', ');
+  const result = withBusyRetry(() => db.prepare(`
+    UPDATE tasks
+       SET status = 'archived',
+           done_at = ?,
+           updated_at = ?,
+           metadata = ?
+     WHERE id = ?
+       AND status IN (${statusPlaceholders})
+  `).run(terminalAt, now, JSON.stringify(metadata), id, ...allowedStatuses));
+  if (result.changes !== 1) return { archived: false, reason: 'stale_task_state' };
+  const updated = getTask(db, id);
+  const event = appendTaskEvent(db, {
+    taskId: id,
+    workspaceRoot: updated.workspace_root,
+    actor: metadata.archived_by,
+    eventType: 'archived',
+    payload: {
+      reason: reasonText,
+      ...(['failed', 'done'].includes(row.status) ? { previous_status: row.status } : {}),
+    },
+  });
+  const logs = appendTaskCompletionLogs(db, updated, {
+    status: 'archived',
+    actor: metadata.archived_by,
+    action: 'archived',
+    proof: reasonText,
+  });
+  return { archived: true, event, row: updated, logs };
+}
+
+// Marks metadata written by the 2026-06-10 "first-principles backlog reset"
+// (see atris/logs/2026/2026-06-10.md) — a bulk pass that closed off-roadmap
+// tasks, including certified/proof-backed done work, by writing status
+// 'failed' because no distinct 'archived' status existed yet. This
+// identifies exactly those rows so relabelArchivedTasks() can fix the label
+// without touching any task that failed for a real reason.
+function isJune10BacklogResetMarker(metadata) {
+  const m = metadata && typeof metadata === 'object' ? metadata : {};
+  if (!m.archived_at) return false;
+  return /first-principles backlog reset 2026-06-10/i.test(String(m.archive_reason || ''));
+}
+
+// One-time migration (OBL-1622): relabel the June-10 mislabeled rows from
+// 'failed' to 'archived'. Dry-run only counts/samples; --apply performs the
+// same status write path as archiveTask() (direct projection UPDATE +
+// appendTaskEvent), never a raw projection-JSON edit.
+function relabelArchivedTasks(db, { workspaceRoot: ws, apply = false, actor, limit = 5000 } = {}) {
+  const candidates = listTasks(db, { workspaceRoot: ws || null, status: 'failed', limit })
+    .filter(row => isJune10BacklogResetMarker(row.metadata));
+  const sample = candidates.slice(0, 10).map(row => ({ id: row.id, title: row.title }));
+  if (!apply) {
+    return { applied: false, count: candidates.length, sample };
+  }
+  const now = Date.now();
+  const actorText = actor || process.env.ATRIS_AGENT_ID || process.env.USER || null;
+  const relabeledIds = [];
+  for (const row of candidates) {
+    const metadata = row.metadata && typeof row.metadata === 'object' ? { ...row.metadata } : {};
+    metadata.relabeled_from_status = 'failed';
+    metadata.relabeled_at = new Date(now).toISOString();
+    metadata.relabeled_by = actorText;
+    metadata.relabel_reason = 'obl_1622_june_10_backlog_reset_relabel';
+    const result = withBusyRetry(() => db.prepare(`
+      UPDATE tasks
+         SET status = 'archived',
+             updated_at = ?,
+             metadata = ?
+       WHERE id = ?
+         AND status = 'failed'
+    `).run(now, JSON.stringify(metadata), row.id));
+    if (result.changes === 1) {
+      appendTaskEvent(db, {
+        taskId: row.id,
+        workspaceRoot: row.workspace_root,
+        actor: actorText,
+        eventType: 'relabeled_archived',
+        payload: { previous_status: 'failed', reason: 'obl_1622_june_10_backlog_reset_relabel' },
+      });
+      relabeledIds.push(row.id);
+    }
+  }
+  return { applied: true, count: relabeledIds.length, ids: relabeledIds, sample };
+}
+
 function cleanLandingText(value) {
   const text = String(value || '').replace(/\s+/g, ' ').trim();
   return text || null;
 }
 
-function readyTask(db, { id, actor, proof, lesson, nextTask, landing = {}, resultTrace }) {
+// Record who delivered this review pass and answer whether certification is
+// allowed: at least one recorded pass actor must differ from the builder.
+// The first pass actor stamps built_by; judge != worker from then on.
+function recordReviewPassActor(metadata, claimedBy, rawActor) {
+  const actorNorm = reviewIntegrity.normalizeActor(
+    rawActor || process.env.ATRIS_AGENT_ID || process.env.USER || ''
+  );
+  if (!metadata.built_by && actorNorm) metadata.built_by = actorNorm;
+  const actors = Array.isArray(metadata.agent_review_actors) ? [...metadata.agent_review_actors] : [];
+  if (actorNorm && !actors.includes(actorNorm)) actors.push(actorNorm);
+  metadata.agent_review_actors = actors;
+  const builder = reviewIntegrity.normalizeActor(metadata.built_by || claimedBy || '');
+  const independent = builder
+    ? (actors.find((a) => a && a !== builder) || null)
+    : (actors.length >= 2 ? actors[1] : null);
+  return { builder: builder || null, independent };
+}
+
+function readyTask(db, { id, actor, proof, lesson, nextTask, landing = {}, resultTrace, result: resultSentence, reason }) {
   if (!id) throw new Error('id required');
   const text = String(proof || '').trim();
   if (!text) throw new Error('proof required');
@@ -562,16 +729,22 @@ function readyTask(db, { id, actor, proof, lesson, nextTask, landing = {}, resul
   metadata.latest_agent_proof = text;
   metadata.latest_agent_lesson = String(lesson || '').trim() || null;
   metadata.latest_agent_next_task = String(nextTask || '').trim() || null;
+  const resultText = cleanLandingText(resultSentence);
+  if (resultText) metadata.result = resultText;
+  const reasonText = cleanLandingText(reason);
+  if (reasonText) metadata.result_reason = reasonText;
   const landingInput = landing && typeof landing === 'object' ? landing : {};
   for (const key of ['happened', 'checked', 'tested', 'decision']) {
     const cleaned = cleanLandingText(landingInput[key]);
     if (cleaned) metadata[`landing_${key}`] = cleaned;
   }
-  if (reviewPassCount >= AGENT_CERTIFICATION_REVIEW_PASSES) {
+  const passRecord = recordReviewPassActor(metadata, row.claimed_by, actor);
+  if (reviewPassCount >= AGENT_CERTIFICATION_REVIEW_PASSES && passRecord.independent) {
     metadata.agent_certified = true;
     metadata.agent_certified_at = new Date(now).toISOString();
     metadata.agent_certified_by = actor || process.env.ATRIS_AGENT_ID || process.env.USER || null;
     metadata.agent_certification_policy = `${AGENT_CERTIFICATION_REVIEW_PASSES}_agent_review_passes`;
+    metadata.independent_review_by = passRecord.independent;
   }
   const result = withBusyRetry(() => db.prepare(`
     UPDATE tasks
@@ -592,6 +765,7 @@ function readyTask(db, { id, actor, proof, lesson, nextTask, landing = {}, resul
     review_pass_count: reviewPassCount,
     agent_certified: metadata.agent_certified === true,
     agent_certification_policy: metadata.agent_certification_policy || null,
+    result: metadata.result || null,
   };
   if (resultTrace && typeof resultTrace === 'object') {
     payload.result_trace = resultTrace;
@@ -613,13 +787,46 @@ function readyTask(db, { id, actor, proof, lesson, nextTask, landing = {}, resul
   return { ready: true, event, row: updated };
 }
 
-function reviseTask(db, { id, actor, note }) {
+function setTaskResult(db, { id, actor, result }) {
+  if (!id) throw new Error('id required');
+  const text = cleanLandingText(result);
+  if (!text) throw new Error('result required');
+  const row = getTask(db, id);
+  if (!row) return { saved: false, reason: 'not_found' };
+  const now = Date.now();
+  const metadata = row.metadata && typeof row.metadata === 'object' ? { ...row.metadata } : {};
+  metadata.result = text;
+  metadata.result_at = new Date(now).toISOString();
+  metadata.result_by = actor || process.env.ATRIS_AGENT_ID || process.env.USER || null;
+  const updated = withBusyRetry(() => db.prepare(`
+    UPDATE tasks
+       SET metadata = ?,
+           updated_at = ?
+     WHERE id = ?
+  `).run(JSON.stringify(metadata), now, id));
+  if (updated.changes !== 1) return { saved: false, reason: 'stale_task_state' };
+  const latest = getTask(db, id);
+  const event = appendTaskEvent(db, {
+    taskId: id,
+    workspaceRoot: latest.workspace_root,
+    actor: metadata.result_by,
+    eventType: 'result_set',
+    payload: { result: text },
+  });
+  return { saved: true, event, row: latest };
+}
+
+function reviseTask(db, { id, actor, note, allowDone = false }) {
   if (!id) throw new Error('id required');
   const text = String(note || '').trim();
   if (!text) throw new Error('note required');
   const row = getTask(db, id);
   if (!row) return { revised: false, reason: 'not_found' };
-  if (row.status !== 'review') {
+  const acceptedDone = allowDone
+    && row.status === 'done'
+    && row.metadata
+    && row.metadata.approval_status === 'accepted';
+  if (row.status !== 'review' && !acceptedDone) {
     return { revised: false, reason: `not_reviewable_${row.status}` };
   }
   const now = Date.now();
@@ -644,7 +851,19 @@ function reviseTask(db, { id, actor, note }) {
   metadata.human_revision_at = new Date(now).toISOString();
   metadata.human_revision_by = actor || process.env.ATRIS_AGENT_ID || process.env.USER || null;
   metadata.human_revision_note = text;
+  if (acceptedDone) {
+    for (const key of [
+      'accepted_at',
+      'accepted_by',
+      'auto_accepted_at',
+      'auto_accepted_by',
+      'auto_accept_policy',
+    ]) {
+      delete metadata[key];
+    }
+  }
   const revisedStatus = row.claimed_by ? 'claimed' : 'open';
+  const expectedStatus = acceptedDone ? 'done' : 'review';
   const result = withBusyRetry(() => db.prepare(`
     UPDATE tasks
        SET status = ?,
@@ -652,8 +871,8 @@ function reviseTask(db, { id, actor, note }) {
            updated_at = ?,
            metadata = ?
      WHERE id = ?
-       AND status = 'review'
-  `).run(revisedStatus, now, JSON.stringify(metadata), id));
+       AND status = ?
+  `).run(revisedStatus, now, JSON.stringify(metadata), id, expectedStatus));
   if (result.changes !== 1) return { revised: false, reason: 'not_updated' };
   const updated = getTask(db, id);
   const event = appendTaskEvent(db, {
@@ -665,6 +884,7 @@ function reviseTask(db, { id, actor, note }) {
       note: text,
       approval_status: 'revise',
       revision_count: revisionCount,
+      ...(acceptedDone ? { previous_status: row.status } : {}),
     },
   });
   const episode = taskEpisodeFromRevision(updated, event, event.payload);
@@ -1170,6 +1390,61 @@ function noteTask(db, { id, actor, content }) {
   return { noted: true, event };
 }
 
+function normalizeTagToken(value) {
+  return String(value == null ? '' : value).trim().toLowerCase();
+}
+
+// Update a task's flag list (`metadata.tags`) on an already-created task.
+// Tags are only settable at creation elsewhere; this is the after-the-fact
+// escape hatch so an open task that becomes an owner decision can be marked
+// `needs-human` — which sweep and fleet staffing both honor — instead of
+// being restaffed forever (CLI-879). Every change appends a
+// `task_tags_updated` event so the trail shows who flagged it and when.
+function tagTask(db, { id, actor, add = [], remove = [] } = {}) {
+  if (!id) throw new Error('id required');
+  const addTags = [...new Set((Array.isArray(add) ? add : [add]).map(normalizeTagToken).filter(Boolean))];
+  const removeSet = new Set((Array.isArray(remove) ? remove : [remove]).map(normalizeTagToken).filter(Boolean));
+  if (!addTags.length && !removeSet.size) return { tagged: false, reason: 'no_tags' };
+  const row = getTask(db, id);
+  if (!row) return { tagged: false, reason: 'not_found' };
+  const metadata = row.metadata && typeof row.metadata === 'object' ? { ...row.metadata } : {};
+  const before = [...new Set((Array.isArray(metadata.tags) ? metadata.tags : []).map(normalizeTagToken).filter(Boolean))];
+  const removed = [];
+  const next = before.filter((tag) => {
+    if (removeSet.has(tag)) { removed.push(tag); return false; }
+    return true;
+  });
+  const added = [];
+  for (const tag of addTags) {
+    // An explicit --remove of the same token wins over --add.
+    if (removeSet.has(tag)) continue;
+    if (!next.includes(tag)) { next.push(tag); added.push(tag); }
+  }
+  if (!added.length && !removed.length) {
+    return { tagged: false, reason: 'no_changes', tags: before };
+  }
+  metadata.tags = next;
+  const actorText = cleanStageText(actor) || null;
+  const now = Math.max(Date.now(), Number(row.updated_at || 0) + 1);
+  const result = withBusyRetry(() => db.prepare(`
+    UPDATE tasks
+       SET metadata = ?,
+           updated_at = ?
+     WHERE id = ?
+       AND updated_at = ?
+  `).run(JSON.stringify(metadata), now, id, row.updated_at));
+  if (result.changes !== 1) return { tagged: false, reason: 'stale_task_state' };
+  const updated = getTask(db, id);
+  const event = appendTaskEvent(db, {
+    taskId: id,
+    workspaceRoot: updated.workspace_root,
+    actor: actorText,
+    eventType: 'task_tags_updated',
+    payload: { added, removed, tags: next, previous_tags: before },
+  });
+  return { tagged: true, event, row: updated, tags: next, added, removed };
+}
+
 function taskChatPacketFromPayload(payload) {
   const data = payload && typeof payload === 'object' ? payload : {};
   const lines = ['TASK_CHAT_UPDATE'];
@@ -1235,7 +1510,7 @@ function chatTask(db, { id, actor, content, goal, summary }) {
   };
 }
 
-function reviewTask(db, { id, actor, reward, lesson, nextTask, proof, verify, careerXpEligible = false, clearedFields = [], landing = {} }) {
+function reviewTask(db, { id, actor, reward, lesson, nextTask, proof, verify, careerXpEligible = false, clearedFields = [], landing = {}, autoAccepted = false }) {
   if (!id) throw new Error('id required');
   const row = getTask(db, id);
   if (!row) return { reviewed: false, reason: 'not_found' };
@@ -1243,6 +1518,14 @@ function reviewTask(db, { id, actor, reward, lesson, nextTask, proof, verify, ca
   const now = Date.now();
   const reviewer = actor || process.env.ATRIS_AGENT_ID || process.env.USER || null;
   const metadata = row.metadata && typeof row.metadata === 'object' ? { ...row.metadata } : {};
+  const reviewerNorm = reviewIntegrity.normalizeActor(reviewer);
+  const builderNorm = reviewIntegrity.taskBuilder(row);
+  // judge != worker applies pre-acceptance only: a builder cannot positive-
+  // reward their own row while it still sits in review. Done rows are past
+  // the human gate; finish and post-acceptance XP bookkeeping stay open.
+  if (numericReward > 0 && row.status === 'review' && builderNorm && reviewerNorm && reviewerNorm === builderNorm) {
+    return { reviewed: false, reason: 'judge_equals_worker', builder: builderNorm };
+  }
   const proofText = String(proof || '').trim();
   const verifyText = cleanStageText(verify);
   const lessonText = String(lesson || '').trim();
@@ -1284,11 +1567,13 @@ function reviewTask(db, { id, actor, reward, lesson, nextTask, proof, verify, ca
   if (reviewingPendingProof) {
     reviewPassCount += 1;
     metadata.agent_review_pass_count = reviewPassCount;
-    if (reviewPassCount >= AGENT_CERTIFICATION_REVIEW_PASSES) {
+    const passRecord = recordReviewPassActor(metadata, row.claimed_by, reviewer);
+    if (reviewPassCount >= AGENT_CERTIFICATION_REVIEW_PASSES && passRecord.independent) {
       metadata.agent_certified = true;
       metadata.agent_certified_at = new Date(now).toISOString();
       metadata.agent_certified_by = reviewer;
       metadata.agent_certification_policy = `${AGENT_CERTIFICATION_REVIEW_PASSES}_agent_review_passes`;
+      metadata.independent_review_by = passRecord.independent;
     }
   }
   if (numericReward > 0 && row.status === 'done') {
@@ -1312,6 +1597,7 @@ function reviewTask(db, { id, actor, reward, lesson, nextTask, proof, verify, ca
     verify: verifyText || null,
     career_xp_eligible: Boolean(careerXpEligible),
   };
+  if (autoAccepted) payload.auto_accepted = true;
   if (reviewingPendingProof) {
     payload.review_pass_count = reviewPassCount;
     payload.agent_certified = metadata.agent_certified === true;
@@ -1637,6 +1923,7 @@ function taskProjection(db, {
         id: row.id,
         ...(refById.get(row.id) || {}),
         title: row.title,
+        result: row.metadata && row.metadata.result || null,
         status: row.status,
         tag: row.tag,
         workspace_root: row.workspace_root,
@@ -1762,11 +2049,16 @@ module.exports = {
   backlogTask,
   clearPlanTasks,
   doneTask,
+  archiveTask,
+  relabelArchivedTasks,
+  isJune10BacklogResetMarker,
   readyTask,
+  setTaskResult,
   reviseTask,
   stageTask,
   noteTask,
   chatTask,
+  tagTask,
   reviewTask,
   appendTaskEvent,
   listTaskEvents,

package/lib/task-proof.js

@@ -7,19 +7,43 @@ const FILE_PROOF_RE = /(?:^|[\s'"`])(?:\.{0,2}\/|~\/|\/Users\/|src\/|scripts\/|a
 const PATH_ONLY_PROOF_RE = /(?:^|[\s'"`])(?:\.{0,2}\/|~\/|\/Users\/|\/private\/|\/var\/|atris\/runs\/|\.atris\/state\/)[^\s'"`,;)]+(?:[.](?:json|jsonl|md|log|txt|png|jpg|jpeg|pdf))?/i;
 const RECEIPT_OR_ARTIFACT_RE = /\b(?:receipt|artifact|screenshot|log|trace|path=|file=|bytes=|model=|opened=|https?:\/\/)\b/i;
 const RESULT_PAIR_RE = /\b(?:typecheck|build|smoke|test|pytest|verifier|validation|validated|verified|render|diff|sync|lineage|projection)\b.{0,80}\b(?:pass|passed|failed|green|ok|exit\s*0|reviewed)\b|\b(?:pass|passed|failed|green|ok|exit\s*0|reviewed)\b.{0,80}\b(?:typecheck|build|smoke|test|pytest|verifier|validation|validated|verified|render|diff|sync|lineage|projection)\b/i;
+const SUITE_GREEN_CLAIM_RE = /\b(?:tests|test\s+suite|suite)\s+(?:is|are|was|were)?\s*(?:all\s+)?(?:green|pass(?:es|ed)?|ok)\b|\b(?:all|full|whole|entire)\s+(?:tests?|test\s+suite|suite)\s+(?:is|are|was|were)?\s*(?:green|pass(?:es|ed)?|ok)\b|\ball\s+green\b|\b(?:npm|pnpm|yarn)\s+(?:run\s+)?test\b\x60?(?:\s+(?:\d+\s*\/\s*\d+|all|suite))?\s+(?:is\s+)?(?:green|pass(?:es|ed)?|ok)\b/i;
+const CI_RUN_CITATION_RE = /https?:\/\/github[.]com\/[^/\s]+\/[^/\s]+\/actions\/runs\/\d+\b|\brun_id\s*=\s*\d+\b|\brun(?:\s+id)?\s*(?:=|:)?\s*\d+\b/i;
+const COMMIT_PINNED_LOCAL_VERIFY_RE = /\bcommit\s+[0-9a-f]{7,40}\b/i;
+const EXIT_ZERO_RE = /\bexit(?:ed)?(?:\s+code)?\s*0\b/i;
+const SUITE_GREEN_CITATION_REASON = 'cite the CI run URL, run id, or commit-pinned verify command with exit 0 before claiming the suite is green';
 const HUMAN_PROOF_RE = /\b(?:team human approved|human approved|human approval|approved by|accepted by|reviewed by|customer replied|customer approved|customer accepted|replied)\b/i;
 const FILE_ACTION_RE = /\b(?:changed|updated|edited|created|deleted|saved|wrote|patched|reviewed|verified|validated|opened|read)\b/i;
+const VERIFIED_PROOF_RE = /^\[verified\]\s+`[^`]+`\s+passed\s+\(exit 0\)(?:\s|$)/i;
+const SECOND_ACTOR_EXECUTED_PROOF_RE = /^Second-actor check:\s+`[^`]+`\s+re-run by [^,]+,\s+exited 0(?:[.\s]|$)/i;
 
 function compactWhitespace(text) {
   return String(text || '').replace(/\s+/g, ' ').trim();
 }
 
+function hasSuiteGreenCitation(text) {
+  return CI_RUN_CITATION_RE.test(text)
+    || (COMMIT_PINNED_LOCAL_VERIFY_RE.test(text)
+      && COMMAND_PROOF_RE.test(text)
+      && EXIT_ZERO_RE.test(text));
+}
+
 function taskProofState(proof) {
   const text = compactWhitespace(proof);
   if (!text) return { ok: false, reason: 'proof required' };
   if (GENERIC_COMPLETION_PROOF_RE.test(text)) {
     return { ok: false, reason: 'proof must name what was verified, changed, approved, or produced' };
   }
+  if (SUITE_GREEN_CLAIM_RE.test(text)) {
+    if (!hasSuiteGreenCitation(text)) {
+      return {
+        ok: false,
+        code: 'suite_green_citation_required',
+        reason: SUITE_GREEN_CITATION_REASON,
+      };
+    }
+    return { ok: true, reason: 'proof cites a CI run or commit-pinned local verify' };
+  }
   if (COMMAND_PROOF_RE.test(text)) return { ok: true, reason: 'proof names a command' };
   if (HUMAN_PROOF_RE.test(text)) return { ok: true, reason: 'proof names human/customer approval' };
   if (RESULT_PAIR_RE.test(text)) return { ok: true, reason: 'proof names a verifier result' };
@@ -37,6 +61,22 @@ function taskProofLooksMeaningful(proof) {
   return taskProofState(proof).ok;
 }
 
+function taskProofExecutionState(proof) {
+  const text = compactWhitespace(proof);
+  if (!text) return { ok: false, reason: 'proof_not_executed', detail: 'executed proof required' };
+  if (VERIFIED_PROOF_RE.test(text)) return { ok: true, reason: 'verified_proof' };
+  if (SECOND_ACTOR_EXECUTED_PROOF_RE.test(text)) return { ok: true, reason: 'second_actor_executed_proof' };
+  return {
+    ok: false,
+    reason: 'proof_not_executed',
+    detail: 'proof must come from an executed verifier, not a free-text claim that tests passed',
+  };
+}
+
+function taskProofLooksExecuted(proof) {
+  return taskProofExecutionState(proof).ok;
+}
+
 function tailText(text, max = 400) {
   const trimmed = String(text || '').trim();
   if (trimmed.length <= max) return trimmed;
@@ -48,7 +88,7 @@ function tailText(text, max = 400) {
 // happily pattern-matches even if nothing ran) and a VERIFIED proof: the command
 // actually executed and exited 0. On failure it returns ok:false so the caller
 // can refuse to mark the task ready. The returned proof string is prefixed
-// `[verified]` and names the command + exit, so it also passes taskProofState.
+// It names the command and exit; suite-green claims still need a citation.
 function buildVerifiedProof(verifyCmd, baseProof = '', runner, options = {}) {
   const cmd = String(verifyCmd || '').trim();
   if (!cmd) return { ok: false, reason: 'verify_command_required' };
@@ -73,6 +113,8 @@ function buildVerifiedProof(verifyCmd, baseProof = '', runner, options = {}) {
 
 module.exports = {
   taskProofLooksMeaningful,
+  taskProofLooksExecuted,
   taskProofState,
+  taskProofExecutionState,
   buildVerifiedProof,
 };