atris 3.15.11 → 3.15.12

package/AGENTS.md

@@ -55,11 +55,22 @@ CHECK → atris review (verify + cleanup)
 
 This workspace has a compiled agent brain.
 
+On session start, activate it first:
+`atris brain activate --root /Users/keshavrao/arena/atris-cli --verify`
+
 Load these first:
+- `atris/now.md`
 - `atris/brain/STATUS.md`
 - `atris/brain/self_improvement_ledger.md`
+- `atris/wiki/concepts/sync-language.md`
+- `atris/skills/activation/SKILL.md`
 - `atris/MAP.md`
-- `atris task list`
+- `atris/TODO.md`
+
+First-message rule: follow the sync-language contract before writing to the operator.
+Purpose: optimize for decision-speed; lead with the move, then use descriptions only when they help the operator act.
+Shape: `<operator>, today is about <move>` -> `I picked this because <why now>` -> `Ready: <draft/proof/context>` -> `Go deeper: <paths>`.
+Definitions: operator = current person or agent; move = one concrete high-leverage workflow; why now = business reason; ready = prepared action or proof; paths = 2-4 optional deeper views.
 
 Re-run after meaningful work:
 `atris brain compile --root /Users/keshavrao/arena/atris-cli`

package/atris/features/company-brain-sync/validate.md

@@ -207,6 +207,27 @@ Validated behavior:
 
 ## Still Needed
 
+- Publish `atris@3.15.12`.
+- Deploy the backend workspace snapshot patch from `atrisos-backend`.
+- After deploy, run a Pallet smoke:
+
+```bash
+npm i -g atris@3.15.12
+cd ~/arena/atris-business/pallet
+atris pull pallet --keep-local --only atris/wiki --timeout 120
+atris push pallet --only atris/wiki --dry-run
+```
+
+- DoorDash post-publish smoke:
+
+```bash
+cd ~/arena/atris-business/doordash
+atris wiki verify
+atris push doordash --dry-run
+```
+
+- Packaged CLI smoke already passed locally for `3.15.12`: tarball install exposes `atris pull --no-manifest` and `atris wiki verify`.
+
 This feature is safer and usable, but the "perfect sync" bar still requires more command-path fixtures and model-assisted semantic merge support.
 
 Missing validation:

package/commands/integrations.js

@@ -326,6 +326,7 @@ function imessageDoctor() {
     chat_db_readable: false,
     sqlite3_available: false,
     osascript_available: false,
+    messages_automation: false,
   };
   const issues = [];
 
@@ -346,10 +347,17 @@ function imessageDoctor() {
 
   checks.osascript_available = spawnSync('osascript', ['-e', 'return "ok"'], { encoding: 'utf8' }).status === 0;
   if (!checks.osascript_available) issues.push('osascript is not available.');
+  if (checks.osascript_available) {
+    checks.messages_automation = spawnSync('osascript', ['-e', 'tell application "Messages" to count services'], {
+      encoding: 'utf8',
+      timeout: 4000,
+    }).status === 0;
+  }
+  if (!checks.messages_automation) issues.push('Messages automation permission is not available yet.');
 
   if (!checks.macos) issues.push('Local iMessage requires macOS.');
 
-  const connected = checks.macos && checks.chat_db_exists && checks.chat_db_readable && checks.sqlite3_available && checks.osascript_available;
+  const connected = checks.macos && checks.chat_db_exists && checks.chat_db_readable && checks.sqlite3_available && checks.osascript_available && checks.messages_automation;
   return {
     connected,
     provider: 'local_imessage',

package/commands/pull.js

@@ -76,7 +76,7 @@ async function pullAtris() {
   let arg = process.argv[3];
 
   if (arg === '--help') {
-    console.log('Usage: atris pull [business] [--into <path>] [--only <prefix>] [--keep-local] [--timeout <seconds>] [--dry-run]');
+    console.log('Usage: atris pull [business] [--into <path>] [--only <prefix>] [--keep-local] [--timeout <seconds>] [--dry-run] [--no-manifest]');
     console.log('');
     console.log('  Pull is force-overwrite by default. Cloud is the source of truth.');
     console.log('  Local files that conflict with cloud are replaced by the cloud version.');
@@ -87,6 +87,7 @@ async function pullAtris() {
     console.log('  atris pull doordash --only atris/wiki/');
     console.log('  atris pull --keep-local      Preserve conflicting local edits as .remote files (legacy)');
     console.log('  atris pull --dry-run         Preview pull changes without writing local files');
+    console.log('  atris pull --no-manifest     Pull for inspection without changing this machine\'s sync anchor');
     return;
   }
 
@@ -176,6 +177,7 @@ async function pullBusiness(slug) {
   const force = !process.argv.includes('--keep-local');
   const failOnConflict = process.argv.includes('--fail-on-conflict');
   const dryRun = process.argv.includes('--dry-run');
+  const noManifest = process.argv.includes('--no-manifest');
 
   // Parse --only flag: comma-separated directory prefixes to filter
   // Supports both --only=team/,context/ and --only team/,context/
@@ -485,6 +487,19 @@ async function pullBusiness(slug) {
   let files = result.data.files || [];
   if (files.length === 0) {
     console.log('  Workspace is empty.');
+    const inScopeLocalBeforePull = Object.keys(localFilesBeforePull).filter((p) => {
+      if (!onlyPrefixes) return true;
+      const rel = p.replace(/^\//, '');
+      return onlyPrefixes.some((pref) => rel.startsWith(pref));
+    }).length;
+    if (!force && inScopeLocalBeforePull > 0) {
+      console.error('');
+      console.error('  Pull stopped: cloud returned zero files while local has in-scope content.');
+      console.error('  This usually means the snapshot endpoint is unhealthy or still warming.');
+      console.error('  No local files or sync manifest were changed.');
+      await emit('status_unknown', { error_detail: 'empty snapshot with local in-scope content' });
+      process.exit(1);
+    }
     // Don't early-return in force mode: we still need to fall through to the
     // mirror sweep so a genuinely-emptied cloud can clear local files. The
     // sweep itself has a safety guard that refuses to wipe local content
@@ -806,12 +821,16 @@ async function pullBusiness(slug) {
     }
     manifestFiles = merged;
   }
-  const newManifest = buildManifest(manifestFiles, commitHash, { workspaceRoot: outputDir });
-  saveManifest(resolvedSlug || slug, newManifest);
-  writeBaseContents(outputDir, remoteContent);
-  removeBaseContents(outputDir, diff.deletedRemote);
+  if (!noManifest) {
+    const newManifest = buildManifest(manifestFiles, commitHash, { workspaceRoot: outputDir });
+    saveManifest(resolvedSlug || slug, newManifest);
+    writeBaseContents(outputDir, remoteContent);
+    removeBaseContents(outputDir, diff.deletedRemote);
+  }
 
-  // Save business config in the output dir so push/status work without args
+  // Save business config in the output dir so push/status work without args.
+  // Inspection pulls should not re-bind the global sync anchor, but the pulled
+  // folder still benefits from a local business marker for navigation.
   const atrisDir = path.join(outputDir, '.atris');
   fs.mkdirSync(atrisDir, { recursive: true });
   fs.writeFileSync(path.join(atrisDir, 'business.json'), JSON.stringify({

package/commands/push.js

@@ -89,6 +89,12 @@ function buildPushChangePlan({
   return { filesToPush, deletedPaths, unchangedCount };
 }
 
+function shouldRetrySyncIndividually(result, filesToPush) {
+  if (!result || result.ok) return false;
+  if (!Array.isArray(filesToPush) || filesToPush.length <= 1) return false;
+  return result.status !== 403 && result.status !== 409;
+}
+
 async function pushAtris() {
   const elapsedMs = startTimer();
   let slug = process.argv[3];
@@ -343,7 +349,7 @@ async function pushAtris() {
 
   if (filesToPush.length === 0 && deletedPaths.length === 0) {
     console.log('\n  Already up to date.\n');
-    await emit('success', { files_unchanged: filteredLocalCount });
+    await emit('success', { files_unchanged: unchangedCount });
     return;
   }
 
@@ -398,6 +404,7 @@ async function pushAtris() {
   let failedToLand = [];
   const landedPaths = new Set();
   let result = { ok: true };
+  let batchFailureDetail = null;
 
   // Server-canonical path format for the /sync endpoint: NO leading slash.
   // The warm runner's _safe_path rejects `/atris/...` with "Absolute path
@@ -410,6 +417,10 @@ async function pushAtris() {
     return s.startsWith('/') ? s : `/${s}`;
   };
   const wireFiles = (files) => files.map((f) => ({ path: toWirePath(f.path), content: f.content }));
+  const syncFiles = (files) => apiRequestJson(
+    `/business/${businessId}/workspaces/${workspaceId}/sync`,
+    { method: 'POST', token: creds.token, body: { files: wireFiles(files) }, headers: { 'X-Atris-Actor-Source': 'cli' } }
+  );
 
   // Inspect per-file results from a /sync response. Treat "written" and
   // "unchanged" as success; everything else (including missing-from-results,
@@ -451,10 +462,7 @@ async function pushAtris() {
 
   if (filesToPush.length > 0) {
     // Push files to server (strip leading slash — server requires workspace-relative paths)
-    result = await apiRequestJson(
-      `/business/${businessId}/workspaces/${workspaceId}/sync`,
-      { method: 'POST', token: creds.token, body: { files: wireFiles(filesToPush) }, headers: { 'X-Atris-Actor-Source': 'cli' } }
-    );
+    result = await syncFiles(filesToPush);
 
     if (!result.ok) {
       if (result.status === 403) {
@@ -469,10 +477,7 @@ async function pushAtris() {
         skipped = filesToPush.filter(f => !f.path.startsWith('/team/') && !f.path.startsWith('/journal/'));
 
         if (allowed.length > 0) {
-          const retry = await apiRequestJson(
-            `/business/${businessId}/workspaces/${workspaceId}/sync`,
-            { method: 'POST', token: creds.token, body: { files: wireFiles(allowed) }, headers: { 'X-Atris-Actor-Source': 'cli' } }
-          );
+          const retry = await syncFiles(allowed);
           if (retry.ok) {
             recordSyncResults(allowed, retry);
             pushed = landedPaths.size;
@@ -490,6 +495,23 @@ async function pushAtris() {
         console.error('\n  Computer is sleeping. Wake it first.');
         await emit('cold_wake', { error_detail: 'computer sleeping (409)' });
         process.exit(1);
+      } else if (shouldRetrySyncIndividually(result, filesToPush)) {
+        batchFailureDetail = `${result.status || 'unknown'}: ${result.errorMessage || result.error || 'batch sync failed'}`;
+        console.log('');
+        console.log(`  Batch push failed (${result.errorMessage || result.error || result.status}). Retrying one file at a time...`);
+        for (const f of filesToPush) {
+          const single = await syncFiles([f]);
+          if (single.ok) {
+            recordSyncResults([f], single);
+          } else {
+            failedToLand.push({
+              path: f.path,
+              status: single.status || 'error',
+              error: single.errorMessage || single.error || '',
+            });
+          }
+        }
+        pushed = landedPaths.size;
       } else {
         console.error(`\n  Push failed: ${result.errorMessage || result.error || result.status}`);
         await emit('status_unknown', { error_detail: `sync status ${result.status}` });
@@ -631,6 +653,9 @@ async function pushAtris() {
   } else if (deleteFailed.length > 0) {
     finalOutcome = 'status_unknown';
     finalDetail = `${deleteFailed.length} delete(s) failed (statuses: ${[...new Set(deleteFailed.map(f => f.status))].join(',')})`;
+  } else if (batchFailureDetail) {
+    finalOutcome = 'status_unknown';
+    finalDetail = `batch sync failed but individual retry landed all files (${batchFailureDetail})`;
   } else if (_rateLimitedDeletes > 0) {
     finalOutcome = 'rate_limited';
     finalDetail = `${_rateLimitedDeletes} delete(s) hit 429 (recovered)`;
@@ -652,6 +677,7 @@ async function pushAtris() {
 module.exports = {
   pushAtris,
   buildPushChangePlan,
+  shouldRetrySyncIndividually,
   resolvePushSourceDir,
   canonicalWorkspaceRoot,
   basenameOfManifestPath,

package/commands/wiki.js

@@ -16,6 +16,7 @@ const {
   buildLintPrompt,
   writeWikiStatus,
   appendWikiLog,
+  validateAgentReadableWikiPages,
 } = require('../lib/wiki');
 
 function autoDetectSlug() {
@@ -331,6 +332,32 @@ function wikiLog(mode, slug, limit) {
   console.log('');
 }
 
+function wikiVerify(mode, slug) {
+  const wikiMode = mode === 'private' ? 'private' : 'public';
+  const wikiDir = findLocalWikiDir(process.cwd(), slug, wikiMode);
+  if (!wikiDir) {
+    console.error(`No local wiki found at ${getWikiRoot(wikiMode)}.`);
+    process.exit(1);
+  }
+
+  const report = validateAgentReadableWikiPages(process.cwd(), wikiMode);
+  console.log('');
+  console.log(`Agent-readable wiki contract: ${report.ok ? 'pass' : 'fail'}`);
+  console.log(`  pages: ${report.pageCount}`);
+  console.log(`  findings: ${report.findingCount}`);
+  if (!report.ok) {
+    for (const finding of report.findings.slice(0, 20)) {
+      console.log(`  - ${finding.page}: ${finding.code} - ${finding.message}`);
+    }
+    if (report.findings.length > 20) {
+      console.log(`  ... +${report.findings.length - 20} more`);
+    }
+    console.log('');
+    process.exit(1);
+  }
+  console.log('');
+}
+
 async function wikiCommand(subcommand, ...args) {
   const { mode, args: cleanArgs } = parseModeArgs(args);
 
@@ -392,8 +419,18 @@ async function wikiCommand(subcommand, ...args) {
       await loopAtris(cleanArgs);
       break;
     }
+    case 'verify':
+    case 'contract': {
+      const slug = mode === 'cloud' ? (cleanArgs[0] || autoDetectSlug()) : null;
+      if (mode === 'cloud') {
+        console.error('Cloud wiki verify is local-first. Run after `atris pull --only atris/wiki --no-manifest` or inside a workspace.');
+        process.exit(1);
+      }
+      wikiVerify(mode, slug);
+      break;
+    }
     default:
-      console.log('Usage: atris wiki <ingest|query|lint|search|log|loop> [business] [args]');
+      console.log('Usage: atris wiki <ingest|query|lint|search|log|loop|verify> [business] [args]');
       console.log('');
       console.log('  ingest <path>                 Local-first ingest into atris/wiki/');
       console.log('  query  "question"             Local-first query against atris/wiki/');
@@ -401,6 +438,7 @@ async function wikiCommand(subcommand, ...args) {
       console.log('  search [business] <term>      Search local atris/wiki/index.md');
       console.log('  log    [business] [N]         Show recent atris/wiki/log.md entries');
       console.log('  loop                          Run local wiki upkeep analysis and refresh STATUS/log');
+      console.log('  verify                        Check agent-readable source/verification metadata');
       console.log('');
       console.log('Flags:');
       console.log('  --cloud                       Route ingest/query/lint to the cloud workspace');
@@ -418,4 +456,5 @@ module.exports = {
   wikiLint,
   wikiSearch,
   wikiLog,
+  wikiVerify,
 };

package/lib/todo-fallback.js

@@ -19,9 +19,25 @@ function parseTodoFile(todoPath) {
   };
 }
 
+function tagsFromText(text) {
+  const allTags = [...String(text || '').matchAll(/\[(\w+)\]/g)].map(m => m[1]);
+  return {
+    allTags,
+    tag: allTags.includes('endgame') ? 'endgame' : (allTags[0] || null),
+  };
+}
+
+function cleanTaskTitle(text) {
+  const raw = String(text || '').trim();
+  const withoutTags = raw.replace(/\s*\[\w+\]/g, '').trim();
+  const bold = withoutTags.match(/^\*\*(.+?)\*\*\s*(?:[—-]\s*)?(.*)$/);
+  if (!bold) return withoutTags;
+  return [bold[1], bold[2]].filter(Boolean).join(' — ').trim();
+}
+
 function parseSection(content, sectionName) {
   const escaped = sectionName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-  const match = content.match(new RegExp(`##\\s+${escaped}\\n([\\s\\S]*?)(?=\\n##|$)`, 'i'));
+  const match = content.match(new RegExp(`(?:^|\\n)##\\s+${escaped}\\s*\\n([\\s\\S]*?)(?=\\n##(?!#)\\s+|$)`, 'i'));
   if (!match) return [];
 
   const body = (match[1] || '').trim();
@@ -34,14 +50,13 @@ function parseSection(content, sectionName) {
   for (const rawLine of lines) {
     const line = rawLine.trimEnd();
 
-    const taskMatch = line.match(/^- \*\*([A-Za-z][A-Za-z0-9#]*\d[a-z]?):\*\*\s*(.+)$/);
+    const taskMatch = line.match(/^- \*\*([^*:\n]+):\*\*\s*(.+)$/);
     if (taskMatch) {
       if (current) tasks.push(current);
-      const allTags = [...taskMatch[2].matchAll(/\[(\w+)\]/g)].map(m => m[1]);
-      const tag = allTags.includes('endgame') ? 'endgame' : (allTags[0] || null);
+      const { allTags, tag } = tagsFromText(taskMatch[2]);
       current = {
         id: taskMatch[1],
-        title: taskMatch[2].replace(/\s*\[\w+\]/g, '').trim(),
+        title: cleanTaskTitle(taskMatch[2]),
         tag,
         tags: allTags,
         claimed: null,
@@ -52,14 +67,24 @@ function parseSection(content, sectionName) {
     }
 
     const checkMatch = line.match(/^- \[[ x]\]\s+(.+)$/);
-    if (checkMatch && !current) {
-      tasks.push({ id: null, title: checkMatch[1].trim(), tag: null, claimed: null, stage: null, verify: null });
+    if (checkMatch) {
+      if (current) {
+        tasks.push(current);
+        current = null;
+      }
+      const { allTags, tag } = tagsFromText(checkMatch[1]);
+      tasks.push({ id: null, title: cleanTaskTitle(checkMatch[1]), tag, tags: allTags, claimed: null, stage: null, verify: null });
       continue;
     }
 
     const plainMatch = line.match(/^- (.+)$/);
-    if (plainMatch && !current && !plainMatch[1].startsWith('**')) {
-      tasks.push({ id: null, title: plainMatch[1].trim(), tag: null, claimed: null, stage: null, verify: null });
+    if (plainMatch && !plainMatch[1].startsWith('**')) {
+      if (current) {
+        tasks.push(current);
+        current = null;
+      }
+      const { allTags, tag } = tagsFromText(plainMatch[1]);
+      tasks.push({ id: null, title: cleanTaskTitle(plainMatch[1]), tag, tags: allTags, claimed: null, stage: null, verify: null });
       continue;
     }
 

package/lib/wiki.js

@@ -457,7 +457,20 @@ function readWikiPages(projectRoot = process.cwd(), mode = 'public') {
 
 function normalizeSourcePath(projectRoot, source) {
   if (!source || /^https?:\/\//i.test(source)) return null;
+  // Source receipts may be external system labels such as "hubspot",
+  // "chorus", or "greenhouse". They are valid evidence labels but not local
+  // files, so stale-file checks should not mark them missing.
+  if (!/[/.]/.test(source)) return null;
   if (path.isAbsolute(source)) return path.normalize(source);
+  if (source.startsWith('context/')) {
+    const atrisContextPath = path.normalize(path.join(projectRoot, 'atris', source));
+    if (fs.existsSync(atrisContextPath)) return atrisContextPath;
+  }
+  if (source.startsWith('team/')) {
+    const atrisTeamPath = path.normalize(path.join(projectRoot, 'atris', source));
+    if (fs.existsSync(atrisTeamPath)) return atrisTeamPath;
+  }
+  if (/^(chorus|hubspot|greenhouse)\//.test(source)) return null;
   return path.normalize(path.join(projectRoot, source));
 }
 
@@ -503,9 +516,20 @@ function findStaleWikiPages(projectRoot = process.cwd(), mode = 'public') {
     .filter(Boolean);
 }
 
-function extractWikiLinks(content) {
+function extractWikiLinks(content, wikiRoot = WIKI_ROOT) {
   const matches = content.match(/\[\[((?:atris\/wiki|\.atris\/presidio)\/[^\]]+?)\]\]/g) || [];
-  return matches.map((match) => match.slice(2, -2));
+  const links = matches.map((match) => match.slice(2, -2));
+  const markdownMatches = content.matchAll(/\[[^\]]+\]\(([^)]+\.md)\)/g);
+  for (const match of markdownMatches) {
+    const raw = String(match[1] || '').trim();
+    if (!raw || /^https?:\/\//i.test(raw) || raw.startsWith('#')) continue;
+    if (raw.startsWith(`${wikiRoot}/`)) {
+      links.push(raw);
+    } else if (!raw.startsWith('/') && !raw.startsWith('..')) {
+      links.push(`${wikiRoot}/${raw}`.replace(/\/+/g, '/'));
+    }
+  }
+  return links;
 }
 
 function findWikiOrphans(projectRoot = process.cwd(), mode = 'public') {
@@ -519,8 +543,10 @@ function findWikiOrphans(projectRoot = process.cwd(), mode = 'public') {
     inboundLinks.set(page.relativePath, 0);
   }
 
+  const indexLinks = new Set(extractWikiLinks(indexContent, wikiRoot).map((link) => link.replace(/\\/g, '/')));
+
   for (const page of pages) {
-    const links = extractWikiLinks(page.content);
+    const links = extractWikiLinks(page.content, wikiRoot);
     for (const link of links) {
       const normalized = link.replace(/\\/g, '/');
       if (normalized !== page.relativePath && inboundLinks.has(normalized)) {
@@ -531,13 +557,66 @@ function findWikiOrphans(projectRoot = process.cwd(), mode = 'public') {
 
   return pages
     .filter((page) => {
-      const indexed = indexContent.includes(`[[${page.relativePath}]]`);
+      const indexed = indexContent.includes(`[[${page.relativePath}]]`) || indexLinks.has(page.relativePath);
       const inboundCount = inboundLinks.get(page.relativePath) || 0;
       return !indexed && inboundCount === 0;
     })
     .map((page) => page.relativePath);
 }
 
+function hasFrontmatterKey(frontmatter, key) {
+  return Object.prototype.hasOwnProperty.call(frontmatter || {}, key);
+}
+
+function isIsoDate(value) {
+  return typeof value === 'string' && /^\d{4}-\d{2}-\d{2}$/.test(value);
+}
+
+function isConfidence(value) {
+  const n = Number(value);
+  return Number.isFinite(n) && n >= 0 && n <= 1;
+}
+
+function validateAgentReadableWikiPages(projectRoot = process.cwd(), mode = 'public') {
+  const findings = [];
+  const pages = readWikiPages(projectRoot, mode);
+  const stalePages = new Set(findStaleWikiPages(projectRoot, mode).map((item) => item.page));
+
+  for (const page of pages) {
+    const fm = page.frontmatter || {};
+    const sources = Array.isArray(fm.sources) ? fm.sources.filter(Boolean) : [];
+
+    if (sources.length === 0) {
+      findings.push({ page: page.relativePath, code: 'missing-sources', message: 'missing source receipt in frontmatter sources' });
+    }
+    if (!isIsoDate(fm.last_compiled)) {
+      findings.push({ page: page.relativePath, code: 'missing-last-compiled', message: 'missing YYYY-MM-DD last_compiled' });
+    }
+    if (!isIsoDate(fm.last_verified)) {
+      findings.push({ page: page.relativePath, code: 'missing-last-verified', message: 'missing YYYY-MM-DD last_verified' });
+    }
+    if (!isConfidence(fm.confidence)) {
+      findings.push({ page: page.relativePath, code: 'missing-confidence', message: 'confidence must be a number from 0 to 1' });
+    }
+    if (!hasFrontmatterKey(fm, 'dependencies') || !Array.isArray(fm.dependencies)) {
+      findings.push({ page: page.relativePath, code: 'missing-dependencies', message: 'dependencies must be present as a list, even if empty' });
+    }
+    if (!String(fm.actionability || '').trim()) {
+      findings.push({ page: page.relativePath, code: 'missing-actionability', message: 'missing actionability summary' });
+    }
+    if (stalePages.has(page.relativePath)) {
+      findings.push({ page: page.relativePath, code: 'stale-source', message: 'source changed since last_compiled or source is missing' });
+    }
+  }
+
+  return {
+    ok: findings.length === 0,
+    pageCount: pages.length,
+    findingCount: findings.length,
+    findings,
+  };
+}
+
 function findSuggestedSources(projectRoot = process.cwd(), limit = 3) {
   const candidates = [
     'README.md',
@@ -743,6 +822,7 @@ module.exports = {
   readWikiPages,
   findStaleWikiPages,
   findWikiOrphans,
+  validateAgentReadableWikiPages,
   findSuggestedSources,
   stageWikiIngest,
   writeWikiStatus,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.15.11",
+  "version": "3.15.12",
   "description": "Atris — an operating system for intelligence. Integrates with any agent.",
   "main": "bin/atris.js",
   "bin": {