atris 3.52.0 → 3.55.0

package/lib/revision-metric.js

@@ -0,0 +1,279 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+const SCHEMA = 'atris.revision_metric.v1';
+const DAILY_SCHEMA = 'atris.revision_metric.daily.v1';
+const ROLLING_DAYS = 7;
+const REVISION_WINDOW_HOURS = 72;
+const HOUR_MS = 60 * 60 * 1000;
+const DAY_MS = 24 * HOUR_MS;
+const REVISION_WINDOW_MS = REVISION_WINDOW_HOURS * HOUR_MS;
+const ATRIS_TRAILER_RE = /^\s*co-authored-by\s*:.*atris-builder\[bot\]/im;
+const IGNORED_FILES = [
+  /^atris\/logs\//,
+  /^atris\/runs\//,
+  /^atris\/team\/[^/]+\/(?:logs|now\.md)/,
+  /^atris\/(?:now|thinking|TODO)\.md$/,
+  /^atris\/MAP\.md$/,
+  /^atris\/brain\//,
+  /^atris\/status\//,
+  /^test\/fast-tests\.txt$/,
+  /^\.atris\//,
+];
+
+function git(root, args) {
+  const result = spawnSync('git', args, {
+    cwd: root,
+    encoding: 'utf8',
+    maxBuffer: 64 * 1024 * 1024,
+  });
+  if (result.error) throw result.error;
+  if (result.status !== 0) {
+    const message = String(result.stderr || result.stdout || `git ${args[0]} exited ${result.status}`).trim();
+    const error = new Error(message);
+    error.gitFailed = true;
+    throw error;
+  }
+  return String(result.stdout || '');
+}
+
+function hasRef(root, ref) {
+  const result = spawnSync('git', ['rev-parse', '--verify', '--quiet', ref], {
+    cwd: root,
+    encoding: 'utf8',
+  });
+  return result.status === 0;
+}
+
+function resolveHistoryRef(root, requestedRef) {
+  const candidates = requestedRef ? [requestedRef] : ['origin/master', 'master', 'HEAD'];
+  const ref = candidates.find((candidate) => hasRef(root, candidate));
+  if (!ref) {
+    const error = new Error('this folder has no readable git history');
+    error.gitFailed = true;
+    throw error;
+  }
+  return ref;
+}
+
+function isAtrisAssistedBody(body) {
+  return ATRIS_TRAILER_RE.test(String(body || ''));
+}
+
+function isRevisionSignalFile(file) {
+  const name = String(file || '').trim();
+  return Boolean(name) && !IGNORED_FILES.some((pattern) => pattern.test(name));
+}
+
+function parseMainlineLog(raw) {
+  return String(raw || '')
+    .split('\x1e')
+    .map((record) => record.replace(/^\n+/, ''))
+    .filter((record) => record.trim())
+    .map((record) => {
+      const [hash, parents, at, authorName, authorEmail, subject, body] = record.split('\x1f');
+      return {
+        hash: String(hash || '').trim(),
+        parents: String(parents || '').trim().split(/\s+/).filter(Boolean),
+        at: String(at || '').trim(),
+        ms: new Date(at).getTime(),
+        authorName: String(authorName || '').trim(),
+        authorEmail: String(authorEmail || '').trim(),
+        subject: String(subject || '').trim(),
+        body: String(body || ''),
+      };
+    })
+    .filter((commit) => commit.hash && Number.isFinite(commit.ms));
+}
+
+function readMainlineCommits(root, ref, sinceIso) {
+  const raw = git(root, [
+    'log', ref, '--first-parent', '--reverse', `--since=${sinceIso}`,
+    '--date=iso-strict',
+    '--pretty=format:%H%x1f%P%x1f%aI%x1f%aN%x1f%aE%x1f%s%x1f%B%x1e',
+  ]);
+  return parseMainlineLog(raw);
+}
+
+function commitFiles(root, commit) {
+  const args = commit.parents.length
+    ? ['diff', '--name-only', commit.parents[0], commit.hash]
+    : ['diff-tree', '--root', '--no-commit-id', '--name-only', '-r', commit.hash];
+  return git(root, args).split(/\r?\n/).map((file) => file.trim()).filter(Boolean);
+}
+
+function sideParentIsAtrisAssisted(root, commit, bodyCache) {
+  if (commit.parents.length < 2) return false;
+  return commit.parents.slice(1).some((parent) => {
+    if (!bodyCache.has(parent)) bodyCache.set(parent, git(root, ['show', '-s', '--format=%B', parent]));
+    return isAtrisAssistedBody(bodyCache.get(parent));
+  });
+}
+
+function isHumanAuthor(commit) {
+  const identity = `${commit.authorName} ${commit.authorEmail}`;
+  return !/\[bot\]|(?:^|[+._-])bot@/i.test(identity);
+}
+
+function summarizeChanges(changes, nowMs, excludedLandings) {
+  const revisionCount = changes.reduce((sum, change) => sum + change.revision_count, 0);
+  const revisedChanges = changes.filter((change) => change.revision_count > 0).length;
+  const stillObserving = changes.filter((change) => nowMs - new Date(change.landed_at).getTime() < REVISION_WINDOW_MS).length;
+  const matureCleanChanges = changes.filter((change) => (
+    change.revision_count === 0
+    && nowMs - new Date(change.landed_at).getTime() >= REVISION_WINDOW_MS
+  )).length;
+  return {
+    days: ROLLING_DAYS,
+    landed_changes: changes.length,
+    revision_count: revisionCount,
+    revised_changes: revisedChanges,
+    clean_so_far: changes.length - revisedChanges,
+    mature_clean_changes: matureCleanChanges,
+    still_observing: stillObserving,
+    excluded_state_only_landings: excludedLandings,
+    target_revision_count: 0,
+  };
+}
+
+function computeRevisionMetric(root = process.cwd(), options = {}) {
+  const now = options.now == null ? new Date() : new Date(options.now);
+  const nowMs = now.getTime();
+  if (!Number.isFinite(nowMs)) throw new Error('now must be a valid date');
+  const ref = resolveHistoryRef(root, options.ref);
+  const windowStart = new Date(nowMs - ROLLING_DAYS * DAY_MS);
+  const commits = readMainlineCommits(root, ref, windowStart.toISOString())
+    .filter((commit) => commit.ms <= nowMs);
+  const bodyCache = new Map();
+  const fileCache = new Map();
+  const filesFor = (commit) => {
+    if (!fileCache.has(commit.hash)) fileCache.set(commit.hash, commitFiles(root, commit));
+    return fileCache.get(commit.hash);
+  };
+  const changes = [];
+  const latestLandingByFile = new Map();
+  let excludedLandings = 0;
+
+  for (const commit of commits) {
+    const atrisAssisted = isAtrisAssistedBody(commit.body)
+      || sideParentIsAtrisAssisted(root, commit, bodyCache);
+    const files = filesFor(commit).filter(isRevisionSignalFile);
+
+    if (atrisAssisted) {
+      if (!files.length) {
+        excludedLandings += 1;
+        continue;
+      }
+      const change = {
+        commit: commit.hash,
+        subject: commit.subject,
+        landed_at: commit.at,
+        files: [...new Set(files)].sort(),
+        revision_count: 0,
+        revisions: [],
+      };
+      const index = changes.push(change) - 1;
+      change.files.forEach((file) => latestLandingByFile.set(file, index));
+      continue;
+    }
+
+    if (commit.parents.length > 1 || !isHumanAuthor(commit) || !files.length) continue;
+    const affected = new Map();
+    for (const file of files) {
+      const landingIndex = latestLandingByFile.get(file);
+      if (landingIndex == null) continue;
+      if (!affected.has(landingIndex)) affected.set(landingIndex, []);
+      affected.get(landingIndex).push(file);
+    }
+    for (const [landingIndex, overlap] of affected) {
+      const landing = changes[landingIndex];
+      const elapsed = commit.ms - new Date(landing.landed_at).getTime();
+      if (elapsed <= 0 || elapsed > REVISION_WINDOW_MS) continue;
+      landing.revisions.push({
+        commit: commit.hash,
+        subject: commit.subject,
+        at: commit.at,
+        files: [...new Set(overlap)].sort(),
+      });
+      landing.revision_count += 1;
+    }
+  }
+
+  return {
+    schema: SCHEMA,
+    generated_at: now.toISOString(),
+    source_ref: ref,
+    window_start: windowStart.toISOString(),
+    window_end: now.toISOString(),
+    signal: {
+      kind: 'proxy',
+      source: 'git_history',
+      landing: 'an atris co-author trailer on a mainline commit or its merged side parent',
+      revision: `a later non-merge human commit touching the latest landing's files within ${REVISION_WINDOW_HOURS} hours`,
+      limitation: 'the trailer proves assistance, not automatic landing; same-file overlap does not prove why the file changed; human commits carrying the trailer cannot be separated',
+      revision_window_hours: REVISION_WINDOW_HOURS,
+    },
+    changes,
+    rolling_7_days: summarizeChanges(changes, nowMs, excludedLandings),
+  };
+}
+
+function utcDate(value) {
+  return new Date(value).toISOString().slice(0, 10);
+}
+
+function dailyRow(metric) {
+  const summary = metric.rolling_7_days;
+  return {
+    schema: DAILY_SCHEMA,
+    date: utcDate(metric.generated_at),
+    day_basis: 'utc',
+    generated_at: metric.generated_at,
+    source_ref: metric.source_ref,
+    rolling_days: summary.days,
+    revision_window_hours: metric.signal.revision_window_hours,
+    landed_changes: summary.landed_changes,
+    revision_count: summary.revision_count,
+    revised_changes: summary.revised_changes,
+    clean_so_far: summary.clean_so_far,
+    mature_clean_changes: summary.mature_clean_changes,
+    still_observing: summary.still_observing,
+    excluded_state_only_landings: summary.excluded_state_only_landings,
+    measurement_kind: metric.signal.kind,
+    signal_source: metric.signal.source,
+  };
+}
+
+function appendDailySummary(root, metric, options = {}) {
+  const file = options.file || path.join(root, '.atris', 'state', 'revision-metric.jsonl');
+  const row = dailyRow(metric);
+  let existing = [];
+  try {
+    existing = fs.readFileSync(file, 'utf8')
+      .split(/\r?\n/)
+      .filter(Boolean)
+      .map((line) => {
+        try { return JSON.parse(line); } catch { return null; }
+      })
+      .filter(Boolean);
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw error;
+  }
+  const sameDay = existing.find((item) => item.schema === DAILY_SCHEMA && item.date === row.date);
+  if (sameDay) {
+    return { appended: false, row: sameDay, path: path.relative(root, file) };
+  }
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.appendFileSync(file, `${JSON.stringify(row)}\n`, 'utf8');
+  return { appended: true, row, path: path.relative(root, file) };
+}
+
+module.exports = {
+  REVISION_WINDOW_HOURS,
+  appendDailySummary,
+  computeRevisionMetric,
+  isRevisionSignalFile,
+};

package/lib/runner-command.js

@@ -67,10 +67,10 @@ const RUNNER_PROFILE_DEFS = Object.freeze({
     model: 'grok-4.6',
     commandTemplate: '{bin} --always-approve -p {prompt}',
   }),
-  droid: Object.freeze({
-    bin: 'droid',
-    model: '',
-    commandTemplate: '{bin} exec {prompt}',
+  agy: Object.freeze({
+    bin: 'agy',
+    model: 'gemini-3.7-flash-high',
+    commandTemplate: '{bin} --mode accept-edits {modelFlag} -p {prompt}',
   }),
 });
 
@@ -80,6 +80,7 @@ const RUNNER_PROFILE_DEFS = Object.freeze({
 const RUNNER_PROFILE_ALIASES = Object.freeze({
   'atris2-fast': 'atris-fast',
   'atris-2-fast': 'atris-fast',
+  antigravity: 'agy',
 });
 
 // Back-compat surface: RUNNER_PROFILES still resolves every accepted name

package/lib/scratch-root.js

@@ -0,0 +1,48 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+// Generic scratch roots. A workspace may live here (dogfood happens), but a
+// child folder is its own room and must not inherit that parent.
+// first-minute folderName already treats these as "this folder".
+const NAMED_SCRATCH_ROOTS = ['/tmp', '/private/tmp', '/var/tmp'];
+
+function pathKey(dir) {
+  return path.resolve(dir || '.').replace(/\\/g, '/');
+}
+
+function genericScratchRoots() {
+  const keys = new Set(NAMED_SCRATCH_ROOTS.map(pathKey));
+  try {
+    keys.add(pathKey(os.tmpdir()));
+  } catch {
+    // os.tmpdir can throw in locked-down hosts.
+  }
+  const resolved = new Set(keys);
+  for (const key of keys) {
+    try {
+      resolved.add(pathKey(fs.realpathSync(key)));
+    } catch {
+      // Missing or unreadable roots stay as the unresolved key.
+    }
+  }
+  return resolved;
+}
+
+function isGenericScratchRoot(dir) {
+  if (!dir) return false;
+  const roots = genericScratchRoots();
+  const key = pathKey(dir);
+  if (roots.has(key)) return true;
+  try {
+    return roots.has(pathKey(fs.realpathSync(dir)));
+  } catch {
+    return false;
+  }
+}
+
+module.exports = {
+  isGenericScratchRoot,
+};

package/lib/skill-eval-gate.js

@@ -0,0 +1,249 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+const SKILL_EVAL_SCHEMA = 'atris.skill_eval.v1';
+const SCORECARDS_PATH = path.join('.atris', 'state', 'scorecards.jsonl');
+const BASE_REFS = Object.freeze(['origin/master', 'origin/main', 'master', 'main']);
+
+function runGit(root, args) {
+  try {
+    return spawnSync('git', args, {
+      cwd: root,
+      encoding: 'utf8',
+      timeout: 10000,
+      maxBuffer: 4 * 1024 * 1024,
+    });
+  } catch (error) {
+    return { status: 1, stdout: '', stderr: String(error && error.message ? error.message : error) };
+  }
+}
+
+function normalizedRelativePath(root, value) {
+  const text = String(value || '').trim().replace(/\\/g, '/');
+  if (!text || text.includes('\0') || path.isAbsolute(text)) return null;
+  const absolute = path.resolve(root, text);
+  const relative = path.relative(root, absolute).replace(/\\/g, '/');
+  if (!relative || relative === '..' || relative.startsWith('../')) return null;
+  return relative;
+}
+
+function nulTerminatedPaths(result, root) {
+  if (!result || result.status !== 0) return [];
+  return String(result.stdout || '')
+    .split('\0')
+    .filter(Boolean)
+    .map((entry) => normalizedRelativePath(root, entry))
+    .filter(Boolean);
+}
+
+function resolveBaseRef(root) {
+  const head = runGit(root, ['rev-parse', '--verify', 'HEAD^{commit}']);
+  if (head.status !== 0) return null;
+  for (const ref of BASE_REFS) {
+    const candidate = runGit(root, ['rev-parse', '--verify', `${ref}^{commit}`]);
+    if (candidate.status === 0) return ref;
+  }
+  return null;
+}
+
+function indexMtime(root) {
+  const result = runGit(root, ['rev-parse', '--git-path', 'index']);
+  if (result.status !== 0) return 0;
+  const value = String(result.stdout || '').trim();
+  const file = path.isAbsolute(value) ? value : path.resolve(root, value);
+  try {
+    return fs.statSync(file).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+
+function fileChangeMtime(root, skillPath) {
+  const absolute = path.join(root, skillPath);
+  try {
+    return fs.statSync(absolute).mtimeMs;
+  } catch {
+    try {
+      return fs.statSync(path.dirname(absolute)).mtimeMs;
+    } catch {
+      return 0;
+    }
+  }
+}
+
+function committedChangeMtime(root, baseRef, skillPath) {
+  if (!baseRef) return 0;
+  const result = runGit(root, [
+    'log',
+    '-1',
+    '--format=%cI',
+    `${baseRef}..HEAD`,
+    '--',
+    skillPath,
+  ]);
+  if (result.status !== 0) return 0;
+  const parsed = Date.parse(String(result.stdout || '').trim());
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
+function changedSkillFiles(workspaceRoot = process.cwd()) {
+  const root = path.resolve(workspaceRoot);
+  const inside = runGit(root, ['rev-parse', '--is-inside-work-tree']);
+  if (inside.status !== 0 || String(inside.stdout || '').trim() !== 'true') return [];
+
+  const changes = new Map();
+  const add = (source, paths) => {
+    for (const relative of paths) {
+      if (path.posix.basename(relative) !== 'SKILL.md') continue;
+      const current = changes.get(relative) || new Set();
+      current.add(source);
+      changes.set(relative, current);
+    }
+  };
+
+  add('worktree', nulTerminatedPaths(runGit(root, ['diff', '--name-only', '-z']), root));
+  add('staged', nulTerminatedPaths(runGit(root, ['diff', '--cached', '--name-only', '-z']), root));
+  add('untracked', nulTerminatedPaths(runGit(root, ['ls-files', '--others', '--exclude-standard', '-z']), root));
+
+  const baseRef = resolveBaseRef(root);
+  if (baseRef) {
+    add('committed', nulTerminatedPaths(
+      runGit(root, ['diff', '--name-only', '-z', `${baseRef}...HEAD`]),
+      root,
+    ));
+  }
+
+  const stagedAt = indexMtime(root);
+  return [...changes.entries()]
+    .map(([skillPath, sources]) => {
+      let changedAtMs = 0;
+      if (sources.has('worktree') || sources.has('untracked')) {
+        changedAtMs = Math.max(changedAtMs, fileChangeMtime(root, skillPath));
+      }
+      if (sources.has('staged')) changedAtMs = Math.max(changedAtMs, stagedAt);
+      if (sources.has('committed')) {
+        changedAtMs = Math.max(changedAtMs, committedChangeMtime(root, baseRef, skillPath));
+      }
+      return {
+        path: skillPath,
+        changed_at_ms: changedAtMs,
+        changed_at: changedAtMs > 0 ? new Date(changedAtMs).toISOString() : null,
+        sources: [...sources].sort(),
+      };
+    })
+    .sort((a, b) => a.path.localeCompare(b.path));
+}
+
+function readSkillEvalReceipts(workspaceRoot = process.cwd()) {
+  const root = path.resolve(workspaceRoot);
+  const file = path.join(root, SCORECARDS_PATH);
+  if (!fs.existsSync(file)) return [];
+  const rows = [];
+  for (const line of fs.readFileSync(file, 'utf8').split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const row = JSON.parse(trimmed);
+      if (row && row.schema === SKILL_EVAL_SCHEMA) rows.push(row);
+    } catch {
+      // Foreign and malformed scorecard rows do not prove a skill evaluation.
+    }
+  }
+  return rows;
+}
+
+function hasRubricScores(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const scores = Object.values(value);
+  return scores.length > 0 && scores.every((score) => Number.isFinite(score));
+}
+
+function normalizedIdentity(value) {
+  return String(value || '').trim().toLowerCase();
+}
+
+function validateSkillEvalReceipt(receipt, skill) {
+  if (!receipt || receipt.schema !== SKILL_EVAL_SCHEMA) {
+    return { ok: false, reason: 'wrong_schema' };
+  }
+  if (String(receipt.skill_path || '').replace(/\\/g, '/') !== skill.path) {
+    return { ok: false, reason: 'wrong_skill_path' };
+  }
+  const receiptAtMs = Date.parse(String(receipt.ts || ''));
+  if (!Number.isFinite(receiptAtMs) || receiptAtMs <= Number(skill.changed_at_ms || 0)) {
+    return { ok: false, reason: 'stale_receipt' };
+  }
+  if (receipt.passed !== true) return { ok: false, reason: 'eval_did_not_pass' };
+  if (!hasRubricScores(receipt.rubric_scores)) {
+    return { ok: false, reason: 'rubric_scores_missing' };
+  }
+  const worker = normalizedIdentity(receipt.worker_model);
+  const judge = normalizedIdentity(receipt.judge_identity);
+  if (!worker || !judge) return { ok: false, reason: 'judge_or_worker_missing' };
+  if (worker === judge) return { ok: false, reason: 'judge_matches_worker' };
+  return { ok: true, receipt_at_ms: receiptAtMs };
+}
+
+function skillEvalGate(workspaceRoot = process.cwd()) {
+  const root = path.resolve(workspaceRoot);
+  const skills = changedSkillFiles(root);
+  if (!skills.length) return { ok: true, skipped: true, skills: [] };
+
+  const receipts = readSkillEvalReceipts(root);
+  const missing = [];
+  const accepted = [];
+  for (const skill of skills) {
+    const candidates = receipts.filter((receipt) => (
+      String(receipt.skill_path || '').replace(/\\/g, '/') === skill.path
+    ));
+    const valid = candidates
+      .map((receipt) => ({ receipt, result: validateSkillEvalReceipt(receipt, skill) }))
+      .filter((entry) => entry.result.ok)
+      .sort((a, b) => b.result.receipt_at_ms - a.result.receipt_at_ms)[0];
+    if (valid) {
+      accepted.push({ path: skill.path, receipt_ts: valid.receipt.ts });
+      continue;
+    }
+    const latest = candidates
+      .map((receipt) => ({ receipt, parsed: Date.parse(String(receipt.ts || '')) }))
+      .filter((entry) => Number.isFinite(entry.parsed))
+      .sort((a, b) => b.parsed - a.parsed)[0];
+    const validation = latest ? validateSkillEvalReceipt(latest.receipt, skill) : null;
+    missing.push({
+      path: skill.path,
+      changed_at: skill.changed_at,
+      reason: validation ? validation.reason : 'receipt_missing',
+    });
+  }
+
+  if (!missing.length) return { ok: true, skills, receipts: accepted };
+  const commands = missing.map((entry) => `atris skill eval ${entry.path}`);
+  return {
+    ok: false,
+    reason: 'skill_eval_receipt_required',
+    offenders: missing.map((entry) => entry.path),
+    missing,
+    message: 'a changed skill has no fresh passing evaluation from a judge different from its worker model, so this work cannot land yet.',
+    next_action: commands.length === 1
+      ? `run \`${commands[0]}\`, then re-certify`
+      : `run a fresh skill evaluation for each changed skill, then re-certify: ${commands.join(', ')}`,
+  };
+}
+
+function appendSkillEvalReceipt(workspaceRoot, receipt) {
+  const root = path.resolve(workspaceRoot || process.cwd());
+  const file = path.join(root, SCORECARDS_PATH);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.appendFileSync(file, `${JSON.stringify(receipt)}\n`, 'utf8');
+  return file;
+}
+
+module.exports = {
+  SKILL_EVAL_SCHEMA,
+  appendSkillEvalReceipt,
+  changedSkillFiles,
+  skillEvalGate,
+};

package/lib/task-db.js

@@ -28,6 +28,7 @@ const os = require('os');
 const crypto = require('crypto');
 const { DatabaseSync } = require('node:sqlite');
 const reviewIntegrity = require('./review-integrity');
+const { isGenericScratchRoot } = require('./scratch-root');
 const { isDecisionTask } = require('./task-decision');
 const { parseVerifyCommand } = require('./auto-accept-certified');
 const { taskExplanation } = require('./task-explanation');
@@ -269,6 +270,9 @@ function findWorkspaceRoot(start) {
       if (test(cur)) return cur;
       const parent = path.dirname(cur);
       if (parent === cur) break;
+      // /tmp (and the other first-minute scratch roots) may themselves be a
+      // workspace. A child of that root is a new room and must not inherit it.
+      if (isGenericScratchRoot(parent)) break;
       cur = parent;
     }
     return null;
@@ -1965,11 +1969,17 @@ function selectProjectionRows(rows, { taskId, includeHistory, doneLimit }) {
     return {
       visibleRows: rows,
       hiddenDoneCount: 0,
+      hiddenArchivedCount: 0,
     };
   }
   const visibleRows = [];
   let shownDone = 0;
   let hiddenDoneCount = 0;
+  // Archived rows get the same recency cap as done rows. Without it the
+  // projection carries every archived task forever (full events/messages) and
+  // the file balloons; `--history` or a taskId still returns everything.
+  let shownArchived = 0;
+  let hiddenArchivedCount = 0;
   for (const row of rows) {
     if (row.status === 'done') {
       if (shownDone < doneLimit) {
@@ -1980,9 +1990,18 @@ function selectProjectionRows(rows, { taskId, includeHistory, doneLimit }) {
       }
       continue;
     }
+    if (row.status === 'archived') {
+      if (shownArchived < doneLimit) {
+        visibleRows.push(row);
+        shownArchived += 1;
+      } else {
+        hiddenArchivedCount += 1;
+      }
+      continue;
+    }
     visibleRows.push(row);
   }
-  return { visibleRows, hiddenDoneCount };
+  return { visibleRows, hiddenDoneCount, hiddenArchivedCount };
 }
 
 function taskProjection(db, {
@@ -2004,7 +2023,7 @@ function taskProjection(db, {
     display_id: row.display_id,
     legacy_ref: row.legacy_ref,
   }]));
-  const { visibleRows, hiddenDoneCount } = selectProjectionRows(rows, {
+  const { visibleRows, hiddenDoneCount, hiddenArchivedCount } = selectProjectionRows(rows, {
     taskId,
     includeHistory,
     doneLimit: Math.max(0, Number(doneLimit) || 0),
@@ -2028,6 +2047,7 @@ function taskProjection(db, {
       full_task_count: rows.length,
       visible_task_count: visibleRows.length,
       hidden_done_count: hiddenDoneCount,
+      hidden_archived_count: hiddenArchivedCount,
       done_limit: includeHistory ? null : Math.max(0, Number(doneLimit) || 0),
       event_limit: includeHistory ? null : Math.max(0, Number(eventLimit) || 0),
       message_limit: includeHistory ? null : Math.max(0, Number(messageLimit) || 0),