atris 3.52.0 → 3.55.0

package/lib/task-proof.js

@@ -8,24 +8,69 @@ const PATH_ONLY_PROOF_RE = /(?:^|[\s'"`])(?:\.{0,2}\/|~\/|\/Users\/|\/private\/|
 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 CI_RUN_URL_RE = /https?:\/\/github[.]com\/[^/\s]+\/[^/\s]+\/actions\/runs\/\d+\b/i;
+const CI_RUN_ID_RE = /\brun_id\s*=\s*\d+\b|\brun(?:\s+id)?\s*(?:=|:)?\s*\d+\b/i;
+const CI_RUN_CITATION_RE = new RegExp(`${CI_RUN_URL_RE.source}|${CI_RUN_ID_RE.source}`, '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 SUITE_GREEN_CITATION_REASON = 'cite a fetched CI run URL (--proof-url with --i-fetched), a run id, or a commit-pinned verify command with exit 0 before claiming the suite is green';
+const LOCAL_SUCCESS_PROOF_EXAMPLE = 'local success example: atris task ready <id> --verify "<cmd>" --result "<plain sentence>" (exit 0 plus the written atris/runs/ receipt path is enough; do not paste a CI URL unless atris fetched it or you pass --proof-url with --i-fetched)';
+const FETCHED_PROOF_URL_RE = /\[(?:fetched|i-fetched)\]\s*https?:\/\/github[.]com\/[^/\s]+\/[^/\s]+\/actions\/runs\/\d+\b/i;
 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 VERIFIED_PROOF_RE = /^\[verified\]\s+`[^`]+`\s+passed\s+\(exit 0\)(?:\s|$)/im;
+const LOCAL_RECEIPT_PATH_RE = /(?:^|[\s])(?:Receipt:\s*)?(?:atris\/runs\/|\.atris\/state\/)[^\s'"`,;)]+\.json\b/i;
 const SECOND_ACTOR_EXECUTED_PROOF_RE = /^Second-actor check:\s+`[^`]+`\s+re-run by [^,]+,\s+exited 0(?:[.\s]|$)/i;
+// Ready/receipt prose may name these. If this process did not run the named
+// command, that sentence is a lie. Keep the list tight: these are the claims
+// that already pass the meaningful-proof floor without executing anything.
+const NAMED_READY_COMMAND_RE = /\b(?:npm test|node --test|git diff --check)\b/i;
+const PROOF_COMMAND_NOT_RUN = 'proof_command_not_run';
 
 function compactWhitespace(text) {
   return String(text || '').replace(/\s+/g, ' ').trim();
 }
 
+function escapeRegExp(text) {
+  return String(text || '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function namedUnrunProofCommand(proof, ranCommand = '') {
+  const text = String(proof || '');
+  const match = text.match(NAMED_READY_COMMAND_RE);
+  if (!match) return '';
+  const named = compactWhitespace(match[0]);
+  const ran = compactWhitespace(ranCommand);
+  if (ran && new RegExp(`\\b${escapeRegExp(named)}\\b`, 'i').test(ran)) return '';
+  return named;
+}
+
+function unrunNamedProofCommandIssue(proof, ranCommand = '') {
+  const named = namedUnrunProofCommand(proof, ranCommand);
+  if (!named) return null;
+  return {
+    reason: PROOF_COMMAND_NOT_RUN,
+    detail: `proof names \`${named}\`, but this process did not run it\nuse --verify "${named}" so the named command actually executes`,
+  };
+}
+
+function hasFetchedCiCitation(text) {
+  return FETCHED_PROOF_URL_RE.test(text);
+}
+
 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));
+  // A pasted actions URL is not proof unless atris fetched it (marked
+  // [fetched]/[i-fetched]) or the caller attested with --i-fetched.
+  if (hasFetchedCiCitation(text)) return true;
+  if (CI_RUN_URL_RE.test(text)) return false;
+  if (CI_RUN_ID_RE.test(text)) return true;
+  return COMMIT_PINNED_LOCAL_VERIFY_RE.test(text)
+    && COMMAND_PROOF_RE.test(text)
+    && EXIT_ZERO_RE.test(text);
+}
+
+function hasLocalVerifiedReceipt(text) {
+  return VERIFIED_PROOF_RE.test(text) && LOCAL_RECEIPT_PATH_RE.test(text);
 }
 
 function taskProofState(proof) {
@@ -34,6 +79,18 @@ function taskProofState(proof) {
   if (GENERIC_COMPLETION_PROOF_RE.test(text)) {
     return { ok: false, reason: 'proof must name what was verified, changed, approved, or produced' };
   }
+  // An executed --verify that exited 0 and wrote an atris/runs receipt is
+  // meaningful proof on its own. Suite-green URL rules apply only to claims.
+  if (hasLocalVerifiedReceipt(text)) {
+    return { ok: true, reason: 'proof is a local verified command with receipt path' };
+  }
+  if (CI_RUN_URL_RE.test(text) && !hasFetchedCiCitation(text) && !SUITE_GREEN_CLAIM_RE.test(text)) {
+    return {
+      ok: false,
+      code: 'unfetched_proof_url',
+      reason: 'CI run URLs only count after atris fetches them, or with --proof-url and --i-fetched',
+    };
+  }
   if (SUITE_GREEN_CLAIM_RE.test(text)) {
     if (!hasSuiteGreenCitation(text)) {
       return {
@@ -42,7 +99,7 @@ function taskProofState(proof) {
         reason: SUITE_GREEN_CITATION_REASON,
       };
     }
-    return { ok: true, reason: 'proof cites a CI run or commit-pinned local verify' };
+    return { ok: true, reason: 'proof cites a fetched 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' };
@@ -80,7 +137,11 @@ function taskProofLooksExecuted(proof) {
 function tailText(text, max = 400) {
   const trimmed = String(text || '').trim();
   if (trimmed.length <= max) return trimmed;
-  return `...${trimmed.slice(-max)}`;
+  // Keep the head as well as the tail: failures name their cause in the first
+  // lines (missing dependency, bad import), which a tail-only cut always loses.
+  const head = Math.floor(max / 2);
+  const tail = max - head;
+  return `${trimmed.slice(0, head)}\n...\n${trimmed.slice(-tail)}`;
 }
 
 // Run a verifier command and turn its real result into proof. This is the
@@ -112,9 +173,14 @@ function buildVerifiedProof(verifyCmd, baseProof = '', runner, options = {}) {
 }
 
 module.exports = {
+  tailText,
   taskProofLooksMeaningful,
   taskProofLooksExecuted,
   taskProofState,
   taskProofExecutionState,
+  namedUnrunProofCommand,
+  unrunNamedProofCommandIssue,
   buildVerifiedProof,
+  LOCAL_SUCCESS_PROOF_EXAMPLE,
+  PROOF_COMMAND_NOT_RUN,
 };

package/lib/task-receipt.js

@@ -14,7 +14,11 @@ const { spawnSync } = require('child_process');
 function tailText(text, max = 400) {
   const trimmed = String(text || '').trim();
   if (trimmed.length <= max) return trimmed;
-  return `...${trimmed.slice(-max)}`;
+  // Keep the head as well as the tail: failures name their cause in the first
+  // lines (missing dependency, bad import), which a tail-only cut always loses.
+  const head = Math.floor(max / 2);
+  const tail = max - head;
+  return `${trimmed.slice(0, head)}\n...\n${trimmed.slice(-tail)}`;
 }
 
 function gitCommitHash(root) {

package/lib/verifier-quality.js

@@ -0,0 +1,69 @@
+'use strict';
+
+// Ready/recap need a stronger bar than "command can fail in an empty dir".
+// A bare `test -f` clears the empty-dir probe and still never exercises the
+// change. Allowlist checks that actually run tests, read a symbol, or do a
+// real diff/syntax check.
+
+function classifyVerifier(command) {
+  const cmd = String(command || '').trim();
+  if (!cmd) return { kind: 'empty', ok: false, reason: 'no verifier command' };
+
+  if (/\b(node\s+--test|npm\s+(?:test|run\s+test(?:\S*)?)|pnpm\s+test|yarn\s+test|pytest\b|go\s+test|cargo\s+test|vitest\b|jest\b)\b/i.test(cmd)) {
+    return { kind: 'test_runner', ok: true, reason: 'test runner' };
+  }
+  if (/\b(git\s+diff\s+--(?:check|exit-code|quiet)|node\s+--check)\b/i.test(cmd)) {
+    return { kind: 'diff_check', ok: true, reason: 'diff or syntax check' };
+  }
+  if (/\b(?:rg|grep)\b/i.test(cmd) && /\S{2,}/.test(cmd.replace(/^(?:rg|grep)\b/i, ''))) {
+    return { kind: 'symbol_read', ok: true, reason: 'symbol or content read' };
+  }
+  if (/\batris\s+(?:verify|drill|slop)\b/i.test(cmd)) {
+    return { kind: 'atris_check', ok: true, reason: 'atris check command' };
+  }
+
+  // Bare file/directory existence: passes when the file is there, says nothing
+  // about whether the change works.
+  if (/^(?:test\s+-[efsdL]\s+\S+|\[\s+-[efsdL]\s+\S+\s*\])(?:\s*(?:&&|\|\|)\s*(?:test\s+-[efsdL]\s+\S+|\[\s+-[efsdL]\s+\S+\s*\]))*$/i.test(cmd)
+    || /^test\s+-[efsdL]\s+\S+$/i.test(cmd)
+    || /^\[\s+-[efsdL]\s+\S+\s*\]$/i.test(cmd)) {
+    return {
+      kind: 'file_exists',
+      ok: false,
+      reason: 'file-exists check does not exercise the change; use a test runner, git diff --check, node --check, or rg/grep for a new symbol',
+    };
+  }
+
+  // Unknown commands still need the empty-dir falsifier; allow them through
+  // that probe. Only bare file-exists is rejected here as not exercising work.
+  return {
+    kind: 'unknown',
+    ok: true,
+    reason: 'custom verifier; empty-dir falsifier still applies',
+  };
+}
+
+function isRealTestRunnerProof(proof) {
+  const flat = String(proof || '').replace(/\s+/g, ' ').trim();
+  if (!flat) return false;
+  return /\b(node\s+--test|npm\s+(?:test|run\s+test(?:\S*)?)|pnpm\s+test|yarn\s+test|pytest\b|go\s+test|cargo\s+test|vitest\b|jest\b)\b/i.test(flat)
+    && /\b(pass|passed|green|ok|0 failures?|\d+\/\d+)\b/i.test(flat);
+}
+
+function quoteVerifierCommand(proof) {
+  const flat = String(proof || '').replace(/\s+/g, ' ').trim();
+  if (!flat) return null;
+  const verified = flat.match(/\[verified\]\s*`([^`]+)`\s*passed/i);
+  if (verified) return verified[1].trim();
+  const backticked = flat.match(/`([^`]+)`/);
+  if (backticked && /\b(test|npm|node|git|rg|grep|pytest|vitest|jest)\b/i.test(backticked[1])) {
+    return backticked[1].trim();
+  }
+  return null;
+}
+
+module.exports = {
+  classifyVerifier,
+  isRealTestRunnerProof,
+  quoteVerifierCommand,
+};

package/lib/wish-audit.js

@@ -1047,13 +1047,13 @@ function auditWish(text, root = process.cwd(), options = {}) {
   } catch {
     validator = null;
   }
-  if (!executor) {
+  if (!executor && !options.cloudRun) {
     const question = 'Which working builder should handle this?';
     const answered = answeredRepeatedQuestionValue(text, root, question, 'builder');
     if (answered) executor = { id: slugify(answered), name: answered };
     else questions.push(question);
   }
-  if (!validator) {
+  if (!validator && !options.cloudRun) {
     const question = 'Which working reviewer should validate it?';
     const answered = answeredRepeatedQuestionValue(text, root, question, 'reviewer');
     if (answered) validator = { id: slugify(answered), name: answered };

package/lib/wish-delegate.js

@@ -1639,9 +1639,18 @@ function applyAnswer(wish, answer, root, options = {}) {
     answers: [...(wish.answers || []), answer],
   };
   const auditText = [wish.text, ...(answeredWish.answers || [])].join(' ');
-  const audited = auditWish(auditText, root, { engineOverride, originalText: wish.text });
+  // A cloud grant runs on the backend, so it never needs a local builder or
+  // reviewer; only clarity questions still apply.
+  const cloudRun = typeof options.cloudDispatch === 'function';
+  const audited = auditWish(auditText, root, { engineOverride, originalText: wish.text, cloudRun });
   const audit = bestGuessAfterRepeatedQuestion(answeredWish, audited, root);
   if (!audit.ok) return askForInput(answeredWish, audit, root, asJson);
+  // --cloud grants hand the answered wish to the backend instead of a local
+  // engine. The caller supplies the dispatcher so this file stays free of the
+  // cloud client.
+  if (typeof options.cloudDispatch === 'function') {
+    return options.cloudDispatch(answeredWish, auditText, root);
+  }
   if (noMission) return captureOnlyWish(answeredWish, audit, root, asJson);
   return delegateWish(answeredWish, audit, root, asJson, { oneLap: wish.one_lap === true });
 }

package/lib/workspace-scaffold.js

@@ -0,0 +1,270 @@
+const fs = require('fs');
+const path = require('path');
+const { ensureWikiScaffold } = require('./wiki');
+
+const PACKAGE_ATRIS_MD = path.join(__dirname, '..', 'atris.md');
+
+function mapPlaceholder() {
+  return '# MAP.md\n\n> Generated by your AI agent after reading atris.md\n\nRun your AI agent with atris.md to populate this file.\n';
+}
+
+function todoPlaceholder() {
+  return `# TODO.md
+
+> Working task queue for this project. Target state = 0.
+> Note: Daily tasks also appear in \`atris/logs/YYYY/YYYY-MM-DD.md\`
+
+---
+
+## Backlog
+
+- **T1:** Generate MAP.md — scan codebase, create navigation index with file:line refs
+
+---
+
+## In Progress
+
+(empty)
+
+---
+
+## Completed
+
+(Validator deletes after verification)
+
+---
+`;
+}
+
+function firstJournalMarkdown(today) {
+  return `# Log — ${today}
+
+## Completed ✅
+
+---
+
+## In Progress 🔄
+
+---
+
+## Backlog
+
+- **T1:** Generate MAP.md — scan codebase, create navigation index with file:line refs
+
+---
+
+## Notes
+
+**Bootstrap:** Say "atris next" to start. After MAP.md is generated, system will brainstorm ideas for your first build.
+
+---
+
+## Inbox
+
+`;
+}
+
+function posixRel(root, filePath) {
+  return path.relative(root, filePath).split(path.sep).join('/');
+}
+
+function writeIfMissing(filePath, content) {
+  if (fs.existsSync(filePath)) return false;
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, content, { encoding: 'utf8', flag: 'wx' });
+  return true;
+}
+
+function copyIfMissing(sourcePath, destPath) {
+  if (fs.existsSync(destPath) || !fs.existsSync(sourcePath)) return false;
+  fs.mkdirSync(path.dirname(destPath), { recursive: true });
+  fs.copyFileSync(sourcePath, destPath);
+  return true;
+}
+
+function ensureDir(dirPath) {
+  if (fs.existsSync(dirPath)) return false;
+  fs.mkdirSync(dirPath, { recursive: true });
+  return true;
+}
+
+function hasDatedLog(logsDir) {
+  if (!fs.existsSync(logsDir)) return false;
+  const walk = (dir) => {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return false;
+    }
+    for (const entry of entries) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (walk(full)) return true;
+      } else if (entry.isFile() && entry.name.endsWith('.md')) {
+        return true;
+      }
+    }
+    return false;
+  };
+  return walk(logsDir);
+}
+
+function workspaceBrainPresent(projectRoot = process.cwd()) {
+  const atrisDir = path.join(projectRoot, 'atris');
+  const required = ['MAP.md', 'TODO.md', 'now.md', 'atris.md', path.join('wiki', 'index.md')];
+  if (!required.every((rel) => fs.existsSync(path.join(atrisDir, rel)))) return false;
+  try {
+    if (!fs.statSync(path.join(atrisDir, 'team')).isDirectory()) return false;
+  } catch {
+    return false;
+  }
+  return hasDatedLog(path.join(atrisDir, 'logs'));
+}
+
+function ensureWorkspaceBrain(projectRoot = process.cwd(), { now = new Date() } = {}) {
+  const created = [];
+  const atrisDir = path.join(projectRoot, 'atris');
+  const note = (filePath) => created.push(posixRel(projectRoot, filePath));
+
+  ensureDir(atrisDir);
+
+  const wikiIndex = path.join(atrisDir, 'wiki', 'index.md');
+  const wikiMissing = !fs.existsSync(wikiIndex);
+  ensureWikiScaffold(projectRoot);
+  if (wikiMissing && fs.existsSync(wikiIndex)) note(wikiIndex);
+
+  const mapFile = path.join(atrisDir, 'MAP.md');
+  if (writeIfMissing(mapFile, mapPlaceholder())) note(mapFile);
+
+  const todoFile = path.join(atrisDir, 'TODO.md');
+  if (writeIfMissing(todoFile, todoPlaceholder())) note(todoFile);
+
+  const nowFile = path.join(atrisDir, 'now.md');
+  if (!fs.existsSync(nowFile)) {
+    const { renderDefaultNow } = require('../commands/now');
+    if (writeIfMissing(nowFile, renderDefaultNow(projectRoot))) note(nowFile);
+  }
+
+  const year = String(now.getFullYear());
+  const today = now.toISOString().split('T')[0];
+  const journalFile = path.join(atrisDir, 'logs', year, `${today}.md`);
+  if (writeIfMissing(journalFile, firstJournalMarkdown(today))) note(journalFile);
+
+  const teamDir = path.join(atrisDir, 'team');
+  if (ensureDir(teamDir)) created.push(posixRel(projectRoot, teamDir) + '/');
+
+  const atrisMd = path.join(atrisDir, 'atris.md');
+  if (copyIfMissing(PACKAGE_ATRIS_MD, atrisMd)) note(atrisMd);
+
+  const taskSeed = seedInitTaskPlane(projectRoot, { todoFile, journalFile });
+
+  return { created, atrisDir, taskSeed };
+}
+
+/**
+ * Seed the SQLite task plane from TODO.md + today's journal so status/task list agree.
+ * Idempotent via source_key and normalized-title dedupe.
+ */
+function seedInitTaskPlane(projectRoot, { todoFile, journalFile } = {}) {
+  try {
+    const taskDb = require('./task-db');
+    const { parseTodoFile, parseSection } = require('./todo-fallback');
+    const { parseInboxItems } = require('./file-ops');
+    const db = taskDb.open();
+    const workspaceRoot = taskDb.workspaceRoot(projectRoot);
+    const existing = taskDb.listTasks(db, { workspaceRoot, limit: 500 });
+    const knownTitles = new Set(existing.map((row) => taskDb.normalizeTitle(row.title)));
+
+    const candidates = [];
+    const todoPath = todoFile || path.join(projectRoot, 'atris', 'TODO.md');
+    if (fs.existsSync(todoPath)) {
+      const parsed = parseTodoFile(todoPath);
+      for (const t of parsed.backlog || []) {
+        candidates.push({ ...t, importStatus: 'open', sourceFile: todoPath });
+      }
+      for (const t of parsed.inProgress || []) {
+        candidates.push({ ...t, importStatus: 'claimed', sourceFile: todoPath });
+      }
+      for (const t of parsed.review || []) {
+        candidates.push({ ...t, importStatus: 'review', sourceFile: todoPath });
+      }
+    }
+
+    const journalPath = journalFile || null;
+    if (journalPath && fs.existsSync(journalPath)) {
+      const content = fs.readFileSync(journalPath, 'utf8');
+      for (const t of parseSection(content, 'Backlog')) {
+        candidates.push({ ...t, importStatus: 'open', sourceFile: journalPath });
+      }
+      for (const t of parseSection(content, 'In Progress')) {
+        candidates.push({ ...t, importStatus: 'claimed', sourceFile: journalPath });
+      }
+      for (const item of parseInboxItems(content)) {
+        candidates.push({
+          id: `I${item.id}`,
+          title: item.text,
+          tag: 'inbox',
+          importStatus: 'open',
+          sourceFile: journalPath,
+        });
+      }
+    }
+
+    let inserted = 0;
+    let skipped = 0;
+    for (const t of candidates) {
+      if (!t.title) continue;
+      const normalized = taskDb.normalizeTitle(t.title);
+      if (knownTitles.has(normalized)) {
+        skipped += 1;
+        continue;
+      }
+      const sk = taskDb.sourceKey(t.sourceFile, t.title);
+      const result = taskDb.addTask(db, {
+        title: t.title,
+        tag: t.tag || null,
+        workspaceRoot,
+        sourceKey: sk,
+        status: t.importStatus || 'open',
+        claimedBy: t.claimed || null,
+        metadata: {
+          source: 'init_seed',
+          todo_id: t.id || null,
+          todo_tags: t.tags || [],
+        },
+      });
+      if (result.inserted) {
+        inserted += 1;
+        knownTitles.add(normalized);
+      } else {
+        skipped += 1;
+      }
+    }
+
+    const rows = taskDb.listTasks(db, { workspaceRoot, limit: 500 });
+    const projection = taskDb.taskProjection(db, { workspaceRoot, limit: 500 });
+    const projectionPath = path.join(projectRoot, '.atris', 'state', 'tasks.projection.json');
+    fs.mkdirSync(path.dirname(projectionPath), { recursive: true });
+    fs.writeFileSync(projectionPath, `${JSON.stringify(projection, null, 2)}\n`, 'utf8');
+    try {
+      fs.writeFileSync(
+        path.join(projectRoot, 'atris', 'TODO.md'),
+        taskDb.renderTodoMarkdown(rows, { title: 'TODO.md' }),
+        'utf8'
+      );
+    } catch {}
+
+    return { ok: true, inserted, skipped, count: rows.length, projectionPath };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error && error.message ? error.message : String(error),
+    };
+  }
+}
+
+module.exports = {
+  ensureWorkspaceBrain,
+  workspaceBrainPresent,
+};

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "atris",
-  "version": "3.52.0",
+  "version": "3.55.0",
   "description": "you say what you want in plain words. atris builds it, checks it, and shows you proof.",
   "main": "bin/atris.js",
   "bin": {
-    "atris": "bin/atris.js",
+    "atris": "bin/atris",
     "ax": "ax"
   },
   "files": [
@@ -13,6 +13,7 @@
     "cli/*.py",
     "commands/",
     "decks/",
+    "scripts/outbound-artifact-gate.js",
     "scripts/agent_worktree.py",
     "scripts/det/",
     "utils/",
@@ -54,6 +55,7 @@
     "atris/team/opus-overnight/START_HERE.md",
     "atris/team/opus-overnight/STEERING.md",
     "atris/team/_template/MEMBER.md",
+    "atris/team/_template/SOUL.md",
     "atris/features/_templates/",
     "atris/features/company-brain-sync/",
     "atris/policies/",