atris 3.15.56 → 3.16.0

package/lib/member-alive.js

@@ -0,0 +1,232 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const MEMBER_OPERATE_PROGRESS_PREFIX = 'ATRIS_MEMBER_OPERATE_PROGRESS\t';
+
+// Wake decisions where the member should NOT run operate work this tick — it is waiting on a
+// human (ask), on a pending review or clean scope (wait), or has no active goal yet (stop).
+const NON_OPERATE_DECISIONS = new Set(['ask', 'wait', 'stop']);
+
+function emitAliveProgress(payload) {
+  process.stderr.write(`${MEMBER_OPERATE_PROGRESS_PREFIX}${JSON.stringify(payload)}\n`);
+}
+
+function stampIso() {
+  return new Date().toISOString();
+}
+
+function parseJsonMaybe(text) {
+  const trimmed = String(text || '').trim();
+  if (!trimmed) return null;
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    const lastLine = trimmed.split(/\r?\n/).filter(Boolean).at(-1);
+    if (!lastLine) return null;
+    try {
+      return JSON.parse(lastLine);
+    } catch {
+      return null;
+    }
+  }
+}
+
+function resolveAtrisBin(explicit) {
+  if (explicit) return explicit;
+  if (process.env.ATRIS_BIN) return process.env.ATRIS_BIN;
+  const local = path.join(__dirname, '..', 'bin', 'atris.js');
+  if (fs.existsSync(local)) return local;
+  return 'atris';
+}
+
+function runCli(bin, args, opts = {}) {
+  const cwd = opts.cwd || process.cwd();
+  const command = bin.endsWith('.js') ? process.execPath : bin;
+  const argv = bin.endsWith('.js') ? [bin, ...args] : args;
+  const result = spawnSync(command, argv, {
+    cwd,
+    encoding: 'utf8',
+    env: process.env,
+    timeout: opts.timeoutMs || 120000,
+  });
+  return {
+    ok: result.status === 0,
+    status: result.status,
+    stdout: result.stdout || '',
+    stderr: result.stderr || '',
+    json: parseJsonMaybe(result.stdout) || parseJsonMaybe(result.stderr),
+  };
+}
+
+function resolveMemberOperateScript(cwd) {
+  const candidates = [
+    path.join(cwd, 'scripts', 'member-operate.mjs'),
+    path.join(cwd, 'scripts', 'member-operate.js'),
+  ];
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+
+function runMemberOperateScript(scriptPath, member, opts) {
+  const args = [
+    scriptPath,
+    member,
+    '--json',
+    '--max-wall',
+    String(Math.max(60, Math.min(1800, Number(opts.maxWallSeconds) || 900))),
+  ];
+  if (opts.execute) {
+    args.push('--execute');
+    if (opts.confirmed) args.push('--confirm-autonomy-policy');
+  }
+  if (opts.agent === 'claude') args.push('--agent', 'claude');
+  if (opts.model) args.push('--model', String(opts.model));
+  if (opts.noPrime) args.push('--no-prime');
+  // Inherit stderr so member-operate progress lines reach the parent alive/loop process live.
+  const result = spawnSync(process.execPath, args, {
+    cwd: opts.cwd || process.cwd(),
+    encoding: 'utf8',
+    env: process.env,
+    timeout: (Number(opts.maxWallSeconds) || 900) * 1000 + 15000,
+    stdio: ['ignore', 'pipe', 'inherit'],
+  });
+  const json = parseJsonMaybe(result.stdout) || parseJsonMaybe(result.stderr);
+  return {
+    ok: result.status === 0 && json?.ok !== false,
+    status: result.status,
+    payload: json,
+    reason: json?.reason || json?.error || (result.status === 0 ? 'operate_complete' : 'operate_failed'),
+    needs_user: Boolean(json?.needs_user),
+    receipt_path: json?.receipt_path || null,
+    stdout: result.stdout,
+    stderr: result.stderr,
+  };
+}
+
+function runAliveTick(name, opts = {}) {
+  const cwd = opts.cwd || process.cwd();
+  const atrisBin = resolveAtrisBin(opts.atrisBin);
+  const startedAt = stampIso();
+  const tick = {
+    schema: 'atris.member_alive_tick.v1',
+    member: name,
+    mode: opts.execute ? 'execute' : 'dry_run',
+    started_at: startedAt,
+  };
+
+  if (opts.execute && opts.confirmed) {
+    emitAliveProgress({ kind: 'phase', text: 'Reading mission and goal…' });
+  }
+
+  if (!opts.noPrime) {
+    tick.prime = runCli(atrisBin, ['member', 'goal-from-mission', name, '--json'], { cwd, timeoutMs: 120000 });
+  }
+
+  const wake = runCli(atrisBin, [
+    'member', 'wake', name, '--json',
+    ...(opts.force ? ['--force'] : []),
+  ], { cwd, timeoutMs: 120000 });
+  tick.wake = wake;
+  const wakeJson = wake.json || {};
+  tick.has_mission = wakeJson.checks?.has_mission === true;
+  tick.has_goal = wakeJson.checks?.has_goal === true;
+  tick.needs_user = Boolean(wakeJson.needs_user);
+  tick.next_command = wakeJson.next_command || null;
+  tick.decision = wakeJson.decision || null;
+  tick.blocked_on_human = false;
+
+  if (!opts.execute || !opts.confirmed) {
+    tick.operate = { ok: true, skipped: true, reason: 'dry_run' };
+    tick.auto_accept = { ok: true, skipped: true, reason: 'dry_run' };
+    tick.status = tick.needs_user ? 'needs_user' : 'planned';
+    tick.reason = 'alive_dry_run';
+    tick.ok = true;
+    tick.finished_at = stampIso();
+    return tick;
+  }
+
+  // Honor the member's own wake judgment. ask/wait/stop all mean "do not force operate work":
+  // ask = blocked on a human, wait = blocked on a pending review or a dirty scope, stop = no goal yet.
+  // Forcing an operate tick in these states is exactly the no-op churn that surfaces as
+  // failed:partial_failure across a whole loop while the member is actually just waiting on you.
+  const wakeDecision = wakeJson.decision || null;
+  if (NON_OPERATE_DECISIONS.has(wakeDecision)) {
+    const reason = wakeJson.reason || `wake_${wakeDecision}`;
+    const blockedOnHuman = wakeDecision === 'ask'
+      || /^open_experiment_/.test(reason)
+      || /^blocked_/.test(reason);
+    tick.operate = { ok: true, skipped: true, reason: `wake_${wakeDecision}` };
+    tick.auto_accept = runCli(atrisBin, [
+      'task', 'auto-accept-certified',
+      '--dry-run',
+      '--limit', String(Math.max(1, Number(opts.autoAcceptLimit) || 8)),
+      '--json',
+    ], { cwd, timeoutMs: 180000 });
+    tick.decision = wakeDecision;
+    tick.needs_user = wakeDecision === 'ask' || tick.needs_user;
+    tick.blocked_on_human = blockedOnHuman;
+    tick.status = wakeDecision === 'ask' ? 'needs_user' : 'waiting';
+    tick.reason = reason;
+    tick.next_command = wakeJson.next_command || tick.next_command;
+    tick.ok = tick.auto_accept.ok !== false;
+    tick.finished_at = stampIso();
+    return tick;
+  }
+
+  const operateScript = resolveMemberOperateScript(cwd);
+  if (!operateScript) {
+    tick.operate = { ok: false, reason: 'member_operate_script_missing' };
+    tick.status = 'blocked';
+    tick.reason = 'missing_member_operate_script';
+    tick.ok = false;
+    tick.finished_at = stampIso();
+    return tick;
+  }
+
+  emitAliveProgress({ kind: 'phase', text: `Running ${name} tick — streaming live below.` });
+  tick.operate = runMemberOperateScript(operateScript, name, {
+    cwd,
+    execute: true,
+    confirmed: true,
+    maxWallSeconds: opts.maxWallSeconds,
+    agent: opts.agent || 'codex',
+    model: opts.model || null,
+    noPrime: true,
+  });
+  tick.needs_user = tick.needs_user || tick.operate.needs_user === true;
+
+  tick.auto_accept = runCli(atrisBin, [
+    'task', 'auto-accept-certified',
+    '--dry-run',
+    '--limit', String(Math.max(1, Number(opts.autoAcceptLimit) || 8)),
+    '--json',
+  ], { cwd, timeoutMs: 180000 });
+
+  const operateOk = tick.operate.ok !== false;
+  const acceptOk = tick.auto_accept.ok !== false;
+  tick.ok = operateOk && acceptOk;
+  tick.status = tick.needs_user
+    ? 'needs_user'
+    : tick.ok
+      ? 'completed'
+      : 'failed';
+  tick.reason = tick.ok
+    ? 'alive_tick_complete'
+    : tick.operate.reason || tick.auto_accept.json?.summary
+      ? 'partial_failure'
+      : 'alive_tick_failed';
+  tick.receipt_path = tick.operate.receipt_path || wakeJson.receipt_path || null;
+  tick.finished_at = stampIso();
+  return tick;
+}
+
+module.exports = {
+  runAliveTick,
+  resolveMemberOperateScript,
+  resolveAtrisBin,
+};

package/lib/policy-lessons.js

@@ -0,0 +1,280 @@
+// Policy lesson mining for the RSI loop (CLI-215).
+//
+// The workspace already records its own history: career XP receipts (human
+// accepts), task episodes (every review turn with an RL label), and
+// scorecards (improve/brain ticks). This module mines that history into a
+// small set of deterministic policy lessons — each one carries the evidence
+// counts it was computed from — and surfaces them at the moment an agent
+// submits proof (`atris task ready`), so the next submission behaves
+// differently than the last. No LLM calls; re-mining refreshes the numbers.
+const fs = require('fs');
+const path = require('path');
+const { RECEIPT_PATH_PATTERN, extractReceiptEvidence } = require('./receipt-evidence');
+
+const POLICY_LESSONS_FILE = path.join('.atris', 'state', 'policy_lessons.json');
+const CAREER_XP_RECEIPTS_FILE = path.join('.atris', 'state', 'career_xp_receipts.jsonl');
+const TASK_EPISODES_FILE = path.join('.atris', 'state', 'task_episodes.jsonl');
+const SCORECARDS_FILE = path.join('.atris', 'state', 'scorecards.jsonl');
+
+// Review actors that are agents, not the human gate. Mining must split the
+// two: agent self-review churn and human accept/bounce are different signals.
+const AGENT_ACTOR_PATTERN = /review|validator|certifier|auto|codex|claude|devin|droid|improver|second-pass|agent|bot/i;
+// "Names a runnable verify command" — the check a reviewer could replay.
+const VERIFY_COMMAND_PATTERN = /\b(npm (run )?test|node --test|node --check|node bin\/|pytest|cargo test|go test|make test|atris verify|grep -q|git diff --check|diff -u|test -[fs])\b|--verify\b|\bverify:\s/;
+const COMMIT_REF_PATTERN = /\bcommit\s+[0-9a-f]{7,40}\b/i;
+
+function readJsonlFile(filePath) {
+  let raw;
+  try {
+    raw = fs.readFileSync(filePath, 'utf8');
+  } catch {
+    return [];
+  }
+  return raw.split('\n').map((line) => {
+    const text = line.trim();
+    if (!text) return null;
+    try { return JSON.parse(text); } catch { return null; }
+  }).filter(Boolean);
+}
+
+function loadHistory(root) {
+  return {
+    receipts: readJsonlFile(path.join(root, CAREER_XP_RECEIPTS_FILE)),
+    episodes: readJsonlFile(path.join(root, TASK_EPISODES_FILE)),
+    scorecards: readJsonlFile(path.join(root, SCORECARDS_FILE)),
+  };
+}
+
+function isAgentActor(actor) {
+  return AGENT_ACTOR_PATTERN.test(String(actor || ''));
+}
+
+function hasReceiptPath(text) {
+  return new RegExp(RECEIPT_PATH_PATTERN.source).test(String(text || ''));
+}
+
+function hasVerifyCommand(text) {
+  return VERIFY_COMMAND_PATTERN.test(String(text || ''));
+}
+
+function bounceCause(episode) {
+  const proof = String(episode.proof || '').trim();
+  if (!proof) return 'empty_proof';
+  if (/supersed/i.test(proof)) return 'superseded';
+  if (/wrong owner|route .*to|owner:/i.test(proof)) return 'wrong_owner';
+  return 'other';
+}
+
+function featureGateCounts(episodes, predicate) {
+  const counts = { accepted_with: 0, accepted_without: 0, revised_with: 0, revised_without: 0 };
+  for (const episode of episodes) {
+    const withFeature = predicate(String(episode.proof || ''));
+    const key = `${episode.rl.label}_${withFeature ? 'with' : 'without'}`;
+    if (key in counts) counts[key] += 1;
+  }
+  return counts;
+}
+
+function acceptRate(withCount, againstCount) {
+  const total = withCount + againstCount;
+  return total > 0 ? withCount / total : null;
+}
+
+// True when proofs carrying the feature get accepted at a higher rate than
+// proofs without it — the bar for emitting a feature lesson at all.
+function featureHelps(counts) {
+  const withRate = acceptRate(counts.accepted_with, counts.revised_with);
+  const withoutRate = acceptRate(counts.accepted_without, counts.revised_without);
+  return withRate !== null && withoutRate !== null && withRate > withoutRate;
+}
+
+function mineProofPolicy(history, opts = {}) {
+  const { receipts = [], episodes = [], scorecards = [] } = history || {};
+  const minHumanReviewed = Number.isFinite(opts.minHumanReviewed) ? opts.minHumanReviewed : 10;
+  const now = opts.now instanceof Date ? opts.now : new Date();
+
+  const reviewed = episodes.filter((e) => e && e.rl && e.action && e.action.actor);
+  const humanReviewed = reviewed.filter((e) => !isAgentActor(e.action.actor));
+  const agentReviewed = reviewed.filter((e) => isAgentActor(e.action.actor));
+  const humanGateEpisodes = humanReviewed.filter((e) => e.rl.label === 'accepted' || e.rl.label === 'revised');
+
+  const accepted = humanGateEpisodes.filter((e) => e.rl.label === 'accepted').length;
+  const revised = humanGateEpisodes.filter((e) => e.rl.label === 'revised').length;
+  const verifyCounts = featureGateCounts(humanGateEpisodes, hasVerifyCommand);
+  const receiptCounts = featureGateCounts(humanGateEpisodes, hasReceiptPath);
+  const commitCounts = featureGateCounts(humanGateEpisodes, (p) => COMMIT_REF_PATTERN.test(p));
+
+  const bounceCauses = {};
+  for (const episode of humanGateEpisodes) {
+    if (episode.rl.label !== 'revised') continue;
+    const cause = bounceCause(episode);
+    bounceCauses[cause] = (bounceCauses[cause] || 0) + 1;
+  }
+
+  const agentReviseTurns = agentReviewed.filter((e) => e.rl.label === 'revised').length;
+  const autoCertifiedReceipts = receipts.filter((r) => isAgentActor(r.actor)).length;
+
+  const improveTicks = scorecards.filter((s) => s && s.schema === 'atris.improve_tick.v1');
+  const brainScorecards = scorecards.filter((s) => s && s.schema === 'atris.brain.scorecard.v1');
+  const avgReward = (rows) => (rows.length
+    ? Math.round((rows.reduce((sum, r) => sum + (Number(r.reward) || 0), 0) / rows.length) * 100) / 100
+    : null);
+
+  const stats = {
+    human_gate: {
+      accepted,
+      revised,
+      verify_command: verifyCounts,
+      receipt_path: receiptCounts,
+      commit_ref: commitCounts,
+      bounce_causes: bounceCauses,
+    },
+    agent_lane: {
+      review_turns: agentReviewed.length,
+      revise_turns: agentReviseTurns,
+      auto_certified_receipts: autoCertifiedReceipts,
+    },
+    scorecards: {
+      total: scorecards.length,
+      improve_ticks: { count: improveTicks.length, avg_reward: avgReward(improveTicks) },
+      brain: { count: brainScorecards.length, avg_reward: avgReward(brainScorecards) },
+    },
+  };
+
+  const lessons = [];
+  const enoughHumanData = humanGateEpisodes.length >= minHumanReviewed;
+
+  if (enoughHumanData && verifyCounts.accepted_with >= 5 && featureHelps(verifyCounts)) {
+    lessons.push({
+      id: 'proof-verify-command',
+      hint_when: 'proof_missing_verify_command',
+      lesson: `Name a runnable verify command in every proof: ${verifyCounts.accepted_with}/${verifyCounts.accepted_with + verifyCounts.revised_with} proofs with one were accepted at the human gate, while ${verifyCounts.revised_without}/${revised} human bounces named none.`,
+      evidence: { source: 'task_episodes.human_gate', ...verifyCounts },
+    });
+  }
+
+  if (enoughHumanData && receiptCounts.accepted_with >= 1 && featureHelps(receiptCounts)) {
+    lessons.push({
+      id: 'proof-live-receipt',
+      hint_when: 'proof_missing_receipt_path',
+      lesson: `Cite a live receipt path (atris/runs/...) whose verifier passed: receipt-backed proofs are ${receiptCounts.accepted_with}/${receiptCounts.accepted_with + receiptCounts.revised_with} at the human gate and auto-review certifies them agent-side with zero human turns, while evidence-less proofs stall in the review lane (${agentReviseTurns} agent revise turns recorded).`,
+      evidence: { source: 'task_episodes + review lane', ...receiptCounts, agent_revise_turns: agentReviseTurns, auto_certified_receipts: autoCertifiedReceipts },
+    });
+  }
+
+  if (enoughHumanData && revised > 0) {
+    const causeSummary = Object.entries(bounceCauses).map(([cause, count]) => `${count} ${cause}`).join(', ');
+    lessons.push({
+      id: 'bounce-causes-routing',
+      hint_when: null,
+      lesson: `Human bounces are routing/staleness problems, not prose problems (${revised} bounces: ${causeSummary}). Before ready: confirm the task owner is right and the work was not superseded.`,
+      evidence: { source: 'task_episodes.human_gate', revised, bounce_causes: bounceCauses },
+    });
+  }
+
+  return {
+    schema: 'atris.policy_lessons.v1',
+    mined_at: now.toISOString(),
+    sources: {
+      career_xp_receipts: receipts.length,
+      task_episodes: episodes.length,
+      scorecards: scorecards.length,
+      human_reviewed_episodes: humanGateEpisodes.length,
+    },
+    stats,
+    lessons,
+  };
+}
+
+// Mirrors the review lane's auto-review bar (autoReviewableEvidence): every
+// named receipt must exist on disk and show a passing verifier. A proof that
+// names a receipt the lane would reject still earns the hint.
+function hasLaneCertifiableReceipt(proof, root) {
+  const evidence = extractReceiptEvidence(proof, root);
+  return Boolean(
+    evidence
+    && !evidence.missing.length
+    && evidence.receipts.length
+    && evidence.receipts.every((entry) => entry.verifier_passed === true),
+  );
+}
+
+function policyHintsForProof(proofText, mined, root = process.cwd()) {
+  const lessons = mined && Array.isArray(mined.lessons) ? mined.lessons : [];
+  if (!lessons.length) return [];
+  const proof = String(proofText || '');
+  const hints = [];
+  for (const lesson of lessons) {
+    if (lesson.hint_when === 'proof_missing_verify_command' && !hasVerifyCommand(proof)) {
+      hints.push({ id: lesson.id, hint: lesson.lesson });
+    } else if (lesson.hint_when === 'proof_missing_receipt_path' && !hasLaneCertifiableReceipt(proof, root)) {
+      hints.push({ id: lesson.id, hint: lesson.lesson });
+    }
+  }
+  return hints;
+}
+
+function policyLessonsPath(root) {
+  return path.join(root, POLICY_LESSONS_FILE);
+}
+
+function readPolicyLessons(root) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(policyLessonsPath(root), 'utf8'));
+    return parsed && parsed.schema === 'atris.policy_lessons.v1' ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function writePolicyLessons(root, mined) {
+  const filePath = policyLessonsPath(root);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(mined, null, 2) + '\n', 'utf8');
+  return filePath;
+}
+
+// Sync mined lessons into atris/lessons.md (the surface agents already read).
+// One line per lesson id; re-mining replaces the line so counts stay fresh
+// instead of stacking stale duplicates.
+function syncLessonsMd(root, mined) {
+  const lessonsPath = path.join(root, 'atris', 'lessons.md');
+  const today = (mined.mined_at || new Date().toISOString()).split('T')[0];
+  const lines = (mined.lessons || []).map((lesson) => ({
+    id: lesson.id,
+    line: `- **[${today}] policy-${lesson.id}** — pass — ${lesson.lesson} (mined from ${mined.sources.career_xp_receipts} receipts / ${mined.sources.task_episodes} episodes / ${mined.sources.scorecards} scorecards)`,
+  }));
+  if (!lines.length) return { path: lessonsPath, written: [] };
+
+  let content;
+  try {
+    content = fs.readFileSync(lessonsPath, 'utf8');
+  } catch {
+    content = '# lessons.md — What We Learned\n\n> Append-only. One line per lesson.\n\n---\n';
+  }
+  const written = [];
+  for (const { id, line } of lines) {
+    const marker = new RegExp(`^- \\*\\*\\[\\d{4}-\\d{2}-\\d{2}\\] policy-${id.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\*\\*.*$`, 'm');
+    if (marker.test(content)) {
+      content = content.replace(marker, line);
+    } else {
+      content = content.replace(/\n*$/, '\n') + line + '\n';
+    }
+    written.push(id);
+  }
+  fs.mkdirSync(path.dirname(lessonsPath), { recursive: true });
+  fs.writeFileSync(lessonsPath, content, 'utf8');
+  return { path: lessonsPath, written };
+}
+
+module.exports = {
+  AGENT_ACTOR_PATTERN,
+  VERIFY_COMMAND_PATTERN,
+  loadHistory,
+  mineProofPolicy,
+  policyHintsForProof,
+  policyLessonsPath,
+  readPolicyLessons,
+  writePolicyLessons,
+  syncLessonsMd,
+};

package/lib/receipt-evidence.js

@@ -0,0 +1,64 @@
+// Receipt evidence extraction for the human accept gate.
+//
+// Agent proofs are free text, but they usually name receipt files under
+// atris/runs/. Validating those paths on disk turns "trust the prose" into
+// "read the verifier state": the queue and accept surfaces show whether the
+// receipts named in a proof exist and whether their verifiers passed. This
+// informs the human gate — it never blocks it.
+const fs = require('fs');
+const path = require('path');
+
+const RECEIPT_PATH_PATTERN = /(?:^|[\s"'`(])((?:atris\/runs|\.atris\/state)\/[^\s"'`),;]+\.json)/g;
+const MAX_RECEIPTS = 5;
+
+// Mirrors mission receipt shapes: result.passed (legacy verifier-only),
+// result.verifier_result.passed (run/tick envelope), result.tick.verifier_passed.
+function receiptVerifierPassed(receipt) {
+  const result = receipt?.result;
+  if (!result || typeof result !== 'object') return null;
+  if (result.passed === true || result.verifier_result?.passed === true || result.tick?.verifier_passed === true) return true;
+  if (result.passed === false || result.verifier_result?.passed === false || result.tick?.verifier_passed === false) return false;
+  return null;
+}
+
+function extractReceiptEvidence(proofText, root = process.cwd()) {
+  const text = String(proofText || '');
+  const found = [];
+  const seen = new Set();
+  const pattern = new RegExp(RECEIPT_PATH_PATTERN.source, 'g');
+  let match;
+  while ((match = pattern.exec(text)) && found.length < MAX_RECEIPTS) {
+    const candidate = match[1];
+    if (candidate.includes('*') || seen.has(candidate)) continue; // glob shorthand or duplicate
+    seen.add(candidate);
+    found.push(candidate);
+  }
+  if (!found.length) return null;
+
+  const receipts = [];
+  const missing = [];
+  for (const rel of found) {
+    let raw;
+    try {
+      raw = fs.readFileSync(path.resolve(root, rel), 'utf8');
+    } catch {
+      missing.push(rel);
+      continue;
+    }
+    let parsed = null;
+    try { parsed = JSON.parse(raw); } catch {}
+    const entry = { path: rel, exists: true, schema: parsed?.schema || null };
+    const passed = receiptVerifierPassed(parsed);
+    if (passed !== null) entry.verifier_passed = passed;
+    if (parsed?.mission_id) entry.mission_id = parsed.mission_id;
+    receipts.push(entry);
+  }
+  return {
+    receipts,
+    missing,
+    // True only when every named receipt exists and none shows a failing verifier.
+    all_passing: receipts.length > 0 && !missing.length && receipts.every((entry) => entry.verifier_passed !== false),
+  };
+}
+
+module.exports = { extractReceiptEvidence, receiptVerifierPassed, RECEIPT_PATH_PATTERN };

package/lib/state-detection.js

@@ -1,6 +1,12 @@
 const fs = require('fs');
 const path = require('path');
 
+const TASK_STATUS_BUCKETS = {
+  backlog: new Set(['open']),
+  inProgress: new Set(['claimed']),
+  completed: new Set(['done', 'failed'])
+};
+
 function isFeatureInProgress(ideaContent) {
   if (!ideaContent || typeof ideaContent !== 'string') return false;
   return /\*\*Status:\*\*\s*in-progress\b/i.test(ideaContent) || /\bstatus:\s*in-progress\b/i.test(ideaContent);
@@ -36,6 +42,9 @@ function getInProgressFeatures(featuresDir) {
 }
 
 function getBacklogTasks(atrisDir) {
+  const dbTasks = getTasksFromDbBucket(atrisDir, 'backlog');
+  if (dbTasks) return dbTasks;
+
   const todoFile = path.join(atrisDir, 'TODO.md');
   const legacyTaskContextFile = path.join(atrisDir, 'TASK_CONTEXTS.md');
   const taskFilePath = fs.existsSync(todoFile)
@@ -60,6 +69,9 @@ function getBacklogTasks(atrisDir) {
 }
 
 function getInProgressTasks(atrisDir) {
+  const dbTasks = getTasksFromDbBucket(atrisDir, 'inProgress');
+  if (dbTasks) return dbTasks;
+
   const todoFile = path.join(atrisDir, 'TODO.md');
   const legacyTaskContextFile = path.join(atrisDir, 'TASK_CONTEXTS.md');
   const taskFilePath = fs.existsSync(todoFile)
@@ -73,6 +85,9 @@ function getInProgressTasks(atrisDir) {
 }
 
 function getCompletedTasks(atrisDir) {
+  const dbTasks = getTasksFromDbBucket(atrisDir, 'completed');
+  if (dbTasks) return dbTasks;
+
   const todoFile = path.join(atrisDir, 'TODO.md');
   const legacyTaskContextFile = path.join(atrisDir, 'TASK_CONTEXTS.md');
   const taskFilePath = fs.existsSync(todoFile)
@@ -111,6 +126,25 @@ function getTasksFromTodoSection(content, sectionName) {
     .map((line) => line.replace(/^-+\s*/, '').trim());
 }
 
+function getTasksFromDbBucket(atrisDir, bucketName) {
+  const statuses = TASK_STATUS_BUCKETS[bucketName];
+  if (!statuses) return null;
+  try {
+    const taskDb = require('./task-db');
+    if (!fs.existsSync(taskDb.getDbPath())) return null;
+    const workspaceRoot = taskDb.workspaceRoot(path.dirname(path.resolve(atrisDir)));
+    const rows = taskDb.listTasks(taskDb.open(), { workspaceRoot, limit: 500 });
+    if (!rows.length) return null;
+    return rows
+      .filter(row => statuses.has(String(row.status || '').toLowerCase()))
+      .map(row => row.title)
+      .filter(Boolean);
+  } catch (e) {
+    if (process.env.ATRIS_DEBUG) console.error('[state-detection] db task read failed:', e.message);
+    return null;
+  }
+}
+
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }