atris 3.37.1 → 3.40.0

package/lib/task-decision.js

@@ -0,0 +1,50 @@
+'use strict';
+
+// Decision rows are human judgment calls, not agent work. Detect them from
+// tags already in the data (primary tag, tags[], metadata.tags). The live
+// marker is needs-human (CLI-879); decision is the same hold under a clearer
+// name. Autonomous pickers must refuse these; list renderers must show them.
+
+const DECISION_HOLD_TAGS = new Set([
+  'needs-human',
+  'needshuman',
+  'decision',
+]);
+
+const DECISION_MARKER = '[decision]';
+const DECISION_REFUSE_REASON = 'decision row: human judgment required';
+
+function normalizeDecisionTag(value) {
+  return String(value == null ? '' : value).trim().toLowerCase().replace(/_/g, '-');
+}
+
+function taskTagTokens(task) {
+  if (!task || typeof task !== 'object') return [];
+  const fromTags = Array.isArray(task.tags) ? task.tags : [];
+  const fromTag = task.tag ? [task.tag] : [];
+  const fromMeta = task.metadata && Array.isArray(task.metadata.tags) ? task.metadata.tags : [];
+  const fromTitle = (String(task.title || '').match(/#([a-z0-9-]+)/gi) || []).map((t) => t.slice(1));
+  return [...fromTag, ...fromTags, ...fromMeta, ...fromTitle]
+    .map(normalizeDecisionTag)
+    .filter(Boolean);
+}
+
+function isDecisionHoldTag(tag) {
+  return DECISION_HOLD_TAGS.has(normalizeDecisionTag(tag));
+}
+
+function isDecisionTask(task) {
+  return taskTagTokens(task).some(isDecisionHoldTag);
+}
+
+function decisionMarkerFor(task) {
+  return isDecisionTask(task) ? DECISION_MARKER : '';
+}
+
+module.exports = {
+  DECISION_REFUSE_REASON,
+  taskTagTokens,
+  isDecisionHoldTag,
+  isDecisionTask,
+  decisionMarkerFor,
+};

package/lib/taste-lessons.js

@@ -0,0 +1,153 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const VERDICTS = new Set(['keep', 'kill', 'more']);
+const SCOPES = new Set(['writing', 'design', 'code', 'any']);
+const STOP_WORDS = new Set([
+  'and', 'are', 'because', 'for', 'from', 'has', 'have', 'into', 'its', 'not', 'of', 'on', 'or',
+  'that', 'the', 'their', 'this', 'to', 'was', 'were', 'with', 'without', 'you', 'your',
+]);
+
+function tastePath(root) {
+  return path.join(root, 'atris', 'taste.json');
+}
+
+function readTaste(root) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(tastePath(root), 'utf8'));
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function slugify(subject) {
+  return String(subject || '')
+    .normalize('NFKD')
+    .replace(/[\u0300-\u036f]/g, '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 80)
+    .replace(/-+$/g, '');
+}
+
+function validEntry(entry) {
+  return entry
+    && typeof entry === 'object'
+    && VERDICTS.has(entry.verdict)
+    && typeof entry.subject === 'string'
+    && entry.subject.trim()
+    && typeof entry.why === 'string'
+    && entry.why.trim()
+    && SCOPES.has(entry.scope)
+    && typeof entry.added === 'string';
+}
+
+function entriesFrom(store) {
+  return Object.entries(store)
+    .filter(([, entry]) => validEntry(entry))
+    .map(([slug, entry]) => ({ slug, ...entry }));
+}
+
+function assertChoice(value, allowed, field) {
+  if (!allowed.has(value)) throw new Error(`${field} must be one of: ${[...allowed].join(', ')}`);
+}
+
+function addTaste({
+  verdict,
+  subject,
+  why,
+  scope = 'any',
+  example,
+  added,
+  root = process.cwd(),
+} = {}) {
+  const cleanVerdict = String(verdict || '').trim().toLowerCase();
+  const cleanSubject = String(subject || '').trim();
+  const cleanWhy = String(why || '').trim();
+  const cleanScope = String(scope || 'any').trim().toLowerCase();
+  const cleanExample = example === undefined ? '' : String(example).trim();
+  const cleanAdded = String(added || '').trim();
+
+  assertChoice(cleanVerdict, VERDICTS, 'verdict');
+  assertChoice(cleanScope, SCOPES, 'scope');
+  if (!cleanSubject) throw new Error('subject is required');
+  if (!cleanWhy) throw new Error('why is required');
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(cleanAdded)) throw new Error('added must be an ISO date');
+
+  const baseSlug = slugify(cleanSubject);
+  if (!baseSlug) throw new Error('subject must contain letters or numbers');
+
+  const store = readTaste(root);
+  let slug = baseSlug;
+  let suffix = 2;
+  while (store[slug] && store[slug].subject !== cleanSubject) {
+    slug = `${baseSlug}-${suffix}`;
+    suffix += 1;
+  }
+
+  const entry = {
+    verdict: cleanVerdict,
+    subject: cleanSubject,
+    why: cleanWhy,
+    scope: cleanScope,
+    ...(cleanExample ? { example: cleanExample } : {}),
+    added: cleanAdded,
+  };
+  store[slug] = entry;
+
+  const file = tastePath(root);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify(store, null, 2)}\n`, 'utf8');
+  return { slug, ...entry };
+}
+
+function listTaste({ root = process.cwd(), scope } = {}) {
+  const cleanScope = scope === undefined ? null : String(scope).trim().toLowerCase();
+  if (cleanScope) assertChoice(cleanScope, SCOPES, 'scope');
+  return entriesFrom(readTaste(root))
+    .filter((entry) => !cleanScope || cleanScope === 'any' || entry.scope === 'any' || entry.scope === cleanScope)
+    .sort((left, right) => right.added.localeCompare(left.added) || left.slug.localeCompare(right.slug));
+}
+
+function keywords(text) {
+  return [...new Set(String(text || '').toLowerCase().split(/[^a-z0-9]+/)
+    .filter((word) => word.length >= 3 && !STOP_WORDS.has(word)))];
+}
+
+function matchTaste({ briefText = '', scope = 'any', root = process.cwd() } = {}) {
+  const cleanScope = SCOPES.has(String(scope || '').toLowerCase())
+    ? String(scope).toLowerCase()
+    : 'any';
+  const briefWords = new Set(keywords(briefText));
+  if (!briefWords.size) return [];
+
+  const matches = [];
+  for (const entry of entriesFrom(readTaste(root))) {
+    if (cleanScope !== 'any' && entry.scope !== 'any' && entry.scope !== cleanScope) continue;
+
+    const subjectMatches = keywords(`${entry.slug} ${entry.subject}`).filter((word) => briefWords.has(word));
+    const whyMatches = keywords(entry.why).filter((word) => briefWords.has(word));
+    const exampleMatches = keywords(entry.example || '').filter((word) => briefWords.has(word));
+    const overlap = new Set([...subjectMatches, ...whyMatches, ...exampleMatches]);
+    if (!overlap.size) continue;
+
+    const scopeScore = entry.scope === cleanScope ? 10_000 : entry.scope === 'any' ? 5_000 : 0;
+    const score = scopeScore
+      + (subjectMatches.length * 300)
+      + (exampleMatches.length * 200)
+      + (whyMatches.length * 100)
+      + [...overlap].reduce((total, word) => total + word.length, 0);
+    matches.push({ ...entry, why_matched: `brief mentions ${[...overlap].join(', ')}`, score });
+  }
+
+  return matches
+    .sort((left, right) => right.score - left.score || left.slug.localeCompare(right.slug))
+    .slice(0, 5)
+    .map(({ score, ...entry }) => entry);
+}
+
+module.exports = { addTaste, listTaste, matchTaste };

package/lib/team-presence.js

@@ -255,6 +255,5 @@ module.exports = {
   ACTIVE_TASK_STATES,
   DEFAULT_FRESHNESS_WINDOW_MS,
   buildTeamPresence,
-  operatorSentence,
   renderTeamPresence,
 };

package/lib/tool-result-encode.js

@@ -4,4 +4,20 @@ function encodeToolResult(result) {
   return Buffer.from(JSON.stringify(result), 'utf8').toString('base64');
 }
 
-module.exports = { encodeToolResult };
+function toolResultEncodingEnabled(env = process.env) {
+  return env.ATRIS_TOOL_RESULT_B64 !== '0';
+}
+
+function buildToolResultBody(callId, result, env = process.env) {
+  if (!toolResultEncodingEnabled(env)) {
+    return { call_id: callId, result };
+  }
+
+  return {
+    call_id: callId,
+    result: encodeToolResult(result),
+    output_encoding: 'base64',
+  };
+}
+
+module.exports = { buildToolResultBody, encodeToolResult, toolResultEncodingEnabled };

package/lib/voice-gate.js

@@ -8,6 +8,17 @@ const {
 } = require('./autoland');
 
 const EM_DASH = /\u2014/;
+const JARGON = /\b(?:idempotent|deterministic|substrate|orchestration|invariant|canonical|materialize|heuristic)\b/gi;
+const JARGON_SUGGESTIONS = {
+  idempotent: 'safe to repeat',
+  deterministic: 'predictable',
+  substrate: 'base',
+  orchestration: 'coordination',
+  invariant: 'rule that must stay true',
+  canonical: 'standard',
+  materialize: 'create',
+  heuristic: 'rule of thumb',
+};
 const NUMBER_WORDS = [
   'no', 'one', 'two', 'three', 'four', 'five', 'six',
   'seven', 'eight', 'nine', 'ten', 'eleven', 'twelve',
@@ -30,7 +41,7 @@ function findingsFor(text, pattern, rule, why) {
   return findings;
 }
 
-function scanText(text) {
+function scanWords(text) {
   const value = String(text || '');
   const findings = findingsFor(value, EM_DASH, 'em-dash', 'use plain punctuation');
   if (hasAgentJargon(value)) {
@@ -62,6 +73,55 @@ function scanText(text) {
   return findings;
 }
 
+function paragraphsFor(text) {
+  return String(text || '')
+    .trim()
+    .split(/\r?\n(?:[ \t]*\r?\n)+/)
+    .map(paragraph => paragraph.trim())
+    .filter(Boolean);
+}
+
+function sentenceCount(text) {
+  const value = String(text || '').replace(/\s+/g, ' ').trim();
+  if (!value) return 0;
+  const endings = value.match(/[.!?]+(?=\s|$)/g) || [];
+  return endings.length + (/[.!?]+$/.test(value) ? 0 : 1);
+}
+
+function scanShape(text) {
+  const paragraphs = paragraphsFor(text);
+  const findings = [];
+  for (const paragraph of paragraphs) {
+    if (sentenceCount(paragraph) > 2) {
+      findings.push({
+        rule: 'dense-block',
+        why: 'add a blank line after every two sentences',
+        snippet: paragraph,
+      });
+    }
+  }
+  if (paragraphs.length > 3) {
+    findings.push({
+      rule: 'too-many-ideas',
+      why: 'split this into messages with no more than three paragraphs each',
+      snippet: paragraphs.slice(3).join('\n\n'),
+    });
+  }
+  for (const match of String(text || '').matchAll(JARGON)) {
+    const suggestion = JARGON_SUGGESTIONS[match[0].toLowerCase()];
+    findings.push({
+      rule: 'jargon',
+      why: `replace "${match[0]}" with "${suggestion}"`,
+      snippet: match[0],
+    });
+  }
+  return findings;
+}
+
+function scanText(text) {
+  return [...scanWords(text), ...scanShape(text)];
+}
+
 function cleanEmDashes(text) {
   return String(text || '')
     .replace(/\s*\u2014\s*/g, ', ')
@@ -86,13 +146,14 @@ function titleCanReplaceId(title) {
 }
 
 function gateForHuman(text, opts = {}) {
+  const shapeIssues = scanShape(text);
   let cleaned = cleanEmDashes(text);
   cleaned = dejargon(cleaned, { preserveTickets: true });
   if (titleCanReplaceId(opts.title)) {
     cleaned = cleaned.replace(globalPattern(voicePatterns.rawUlid), '');
   }
   cleaned = cleanAfterRemoval(cleaned);
-  const issues = scanText(cleaned);
+  const issues = [...scanWords(cleaned), ...shapeIssues];
   return { ok: issues.length === 0, text: cleaned, issues };
 }
 
@@ -154,10 +215,76 @@ function isRetiredFillerReason(text) {
   return RETIRED_FILLER_REASON.test(String(text || '').replace(/\s+/g, ' ').trim());
 }
 
+// One table turns every landing/refusal reason code into a plain sentence a
+// fried reader can act on: what happened, and what unblocks it. JSON output
+// keeps the raw codes; only human text goes through here. Fragments carry no
+// trailing period because callers stitch them into their own sentences.
+const LANDING_REASON_SENTENCES = {
+  accept_all_but_protected: 'the accept-everything policy covers it, so it lands unless a protected lane applies',
+  already_auto_accepted: 'it already landed on its own earlier, nothing left to do',
+  autoland_policy_missing_owner: 'the self-landing policy has no owner recorded, turn it on again to set one',
+  autoland_policy_off: 'self-landing is off, so everything waits for you',
+  certified_independent_review: 'an independent reviewer certified it, so it can land',
+  certified_strict_verify: 'it is certified and its recorded check passed, so it can land',
+  dead_exports: 'the change leaves behind code nothing calls, delete what the hygiene check names and re-certify',
+  declared_protected_lane: 'it touches a protected lane, so it waits for your decision',
+  forced_completion_needs_human: 'it was pushed to done without proof, so only a human can accept it',
+  insufficient_review_passes: 'it has not been reviewed enough times yet, one more pass unblocks it',
+  judge_equals_worker: 'built and judged by the same actor, hand the review to someone else',
+  mission_xp_requires_end_to_end_receipt: 'the proof does not show the whole flow working start to finish, attach that receipt or move it back to do',
+  needs_independent_reviewer: 'built and judged by the same actor, a review from someone else unblocks it',
+  needs_second_actor_review: 'the same actor built and reviewed it, someone else has to look before it lands',
+  needs_second_reviewer_or_third_pass: 'it needs one more independent check first',
+  no_verify_command: 'no check command was given, add one so the work can prove itself',
+  not_agent_certified: 'no reviewer has certified it yet, a second review unblocks it',
+  not_in_review: 'it is not up for review yet, finish the work and move it to review first',
+  probation_needs_review: 'the builder is still earning trust, so a human look is required before it lands',
+  proof_not_executed: 'the proof was written but never actually run, execute the check and record what it showed',
+  proof_required: 'no proof was given, say what was run and what it showed',
+  proof_unmerged_or_draft_pr_boundary: 'its proof points at an unmerged draft, merge it or prove the work another way',
+  receipt_verifier_failed: 'a saved receipt failed its re-check, fix what it names and re-certify',
+  strict_verify_missing: 'no recorded check command to re-run, add one and re-certify',
+  untagged_protected_lane_text: 'the description reads like protected-lane work without the tag, tag it or decide it yourself',
+  verification_pending: 'the recorded check has not been re-run yet, the next hourly pass runs it',
+  verifier_is_builder: 'the re-check actor built this row, another actor must re-check',
+  verify_command_not_allowed: 'its recorded check is not on the list this machine may run alone, run it yourself to unblock',
+  verify_failed: 'its check command failed on re-run, fix the failure and re-certify',
+  verify_passed: 'its check command passed on re-run',
+  verify_unrunnable: 'its check command could not even start, fix the command and re-certify',
+  verify_workdir_missing: 'the folder its check was recorded in is gone, re-run the check from a real folder',
+  verify_worktree_missing: 'the folder its check needs is gone, rebuild it or run the check by hand',
+  weak_proof: 'the proof is too thin to trust, cite a command, receipt, or approval',
+};
+
+const DENIED_TAG_SENTENCES = {
+  billing: 'it touches money, so it is your decision',
+  deploy: 'it is a deploy, so it is your decision',
+  security: 'it touches security, so it is your decision',
+  customer: 'it is customer-facing, so it is your decision',
+  external: 'it is outward-facing, so it is your decision',
+  feedback: 'it answers customer feedback, so it is your decision',
+};
+
+function plainLandingReason(reason) {
+  const code = String(reason || '').trim();
+  if (!code) return 'no reason was recorded, re-run the review to get one';
+  if (LANDING_REASON_SENTENCES[code]) return LANDING_REASON_SENTENCES[code];
+  const denied = code.match(/^denied_tag_(.+)$/);
+  if (denied) {
+    return DENIED_TAG_SENTENCES[denied[1]]
+      || `it is tagged ${denied[1].replace(/_/g, ' ')}, a protected lane, so it is your decision`;
+  }
+  const approval = code.match(/^approval_(.+)$/);
+  if (approval) return `a human already marked it ${approval[1].replace(/_/g, ' ')}, so it will not land on its own`;
+  // Unknown codes still never leak snake_case to a human.
+  return code.replace(/_/g, ' ');
+}
+
 module.exports = {
   gateForHuman,
   isRetiredFillerReason,
   landingWhyClause,
   numberWord,
+  plainLandingReason,
   scanText,
 };

package/lib/wiki.js

@@ -11,6 +11,13 @@ const LEGACY_WIKI_BRIEFS_SUBDIR = 'syntheses';
 const WIKI_SUBDIRS = ['people', 'systems', 'concepts', WIKI_BRIEFS_SUBDIR];
 const WIKI_STATUS_FILE = 'STATUS.md';
 const WIKI_CONTENT_SUBDIRS = WIKI_SUBDIRS.map((subdir) => path.join(WIKI_ROOT, subdir));
+const WIKI_METABOLISM_MARKER = path.join('.atris', 'state', 'wiki.metabolism.json');
+const DEFAULT_WIKI_METABOLISM_BUDGETS = Object.freeze({
+  index: 40,
+  log: 60,
+  folder: 30,
+});
+const CONSOLIDATION_GROWTH_THRESHOLD = 10;
 
 function getWikiRoot(mode = 'public') {
   return mode === 'private' ? PRIVATE_WIKI_ROOT : WIKI_ROOT;
@@ -577,7 +584,122 @@ function isConfidence(value) {
   return Number.isFinite(n) && n >= 0 && n <= 1;
 }
 
-function validateAgentReadableWikiPages(projectRoot = process.cwd(), mode = 'public') {
+function countBullets(filePath, topLevelOnly = false) {
+  if (!fs.existsSync(filePath)) return 0;
+  const pattern = topLevelOnly ? /^-\s+\S/ : /^\s*-\s+\S/;
+  return fs.readFileSync(filePath, 'utf8')
+    .split('\n')
+    .filter((line) => pattern.test(line))
+    .length;
+}
+
+function countWikiMetabolismEntries(projectRoot = process.cwd(), mode = 'public') {
+  const wikiDir = path.join(projectRoot, getWikiRoot(mode));
+  const counts = {
+    'index.md': countBullets(path.join(wikiDir, 'index.md')),
+    'log.md': countBullets(path.join(wikiDir, 'log.md'), true),
+  };
+
+  for (const subdir of WIKI_SUBDIRS) {
+    counts[`${subdir}/`] = walkMarkdownFiles(path.join(wikiDir, subdir)).length;
+  }
+
+  return counts;
+}
+
+function readWikiMetabolismMarker(projectRoot = process.cwd()) {
+  const markerPath = path.join(projectRoot, WIKI_METABOLISM_MARKER);
+  if (!fs.existsSync(markerPath)) return null;
+
+  try {
+    const marker = JSON.parse(fs.readFileSync(markerPath, 'utf8'));
+    if (!marker || typeof marker !== 'object' || !marker.entryCountAtConsolidation || typeof marker.entryCountAtConsolidation !== 'object') {
+      return null;
+    }
+    return marker;
+  } catch {
+    return null;
+  }
+}
+
+function writeWikiMetabolismMarker(projectRoot = process.cwd(), entryCounts = {}, lastConsolidatedAt = new Date().toISOString()) {
+  const markerPath = path.join(projectRoot, WIKI_METABOLISM_MARKER);
+  const marker = {
+    lastConsolidatedAt,
+    entryCountAtConsolidation: { ...entryCounts },
+  };
+  fs.mkdirSync(path.dirname(markerPath), { recursive: true });
+  fs.writeFileSync(markerPath, `${JSON.stringify(marker, null, 2)}\n`, 'utf8');
+  return marker;
+}
+
+function wikiBudgetForSurface(surface, budgets) {
+  if (surface === 'index.md') return Number.isFinite(budgets.index) ? budgets.index : DEFAULT_WIKI_METABOLISM_BUDGETS.index;
+  if (surface === 'log.md') return Number.isFinite(budgets.log) ? budgets.log : DEFAULT_WIKI_METABOLISM_BUDGETS.log;
+  const folder = surface.replace(/\/$/, '');
+  if (budgets.folders && Number.isFinite(budgets.folders[folder])) return budgets.folders[folder];
+  if (Number.isFinite(budgets[folder])) return budgets[folder];
+  return Number.isFinite(budgets.folder) ? budgets.folder : DEFAULT_WIKI_METABOLISM_BUDGETS.folder;
+}
+
+function wikiMetabolismSurfacePath(surface, mode = 'public') {
+  return `${getWikiRoot(mode)}/${surface}`;
+}
+
+function findWikiMetabolismFindings(projectRoot = process.cwd(), mode = 'public', budgets = DEFAULT_WIKI_METABOLISM_BUDGETS) {
+  const counts = countWikiMetabolismEntries(projectRoot, mode);
+  const marker = readWikiMetabolismMarker(projectRoot);
+  const findings = [];
+
+  for (const [surface, count] of Object.entries(counts)) {
+    const budget = wikiBudgetForSurface(surface, budgets || {});
+    const page = wikiMetabolismSurfacePath(surface, mode);
+    if (count > budget) {
+      findings.push({
+        page,
+        surface,
+        code: 'over-budget',
+        count,
+        budget,
+        message: `${surface} has ${count} entries, over budget ${budget}`,
+      });
+    }
+
+    const baseline = Number(marker?.entryCountAtConsolidation?.[surface]);
+    const growth = Number.isFinite(baseline) ? count - baseline : 0;
+    if (growth >= CONSOLIDATION_GROWTH_THRESHOLD) {
+      findings.push({
+        page,
+        surface,
+        code: 'consolidation-due',
+        count,
+        baselineCount: baseline,
+        growth,
+        message: `${surface} grew by ${growth} entries since the last consolidation`,
+      });
+    }
+  }
+
+  return findings;
+}
+
+function wikiMetabolismNudge(projectRoot = process.cwd(), mode = 'public') {
+  try {
+    const findings = findWikiMetabolismFindings(projectRoot, mode);
+    return findings.length > 0
+      ? 'the wiki has grown a lot since its last pruning; run: atris wiki consolidate'
+      : '';
+  } catch {
+    return '';
+  }
+}
+
+function recordWikiConsolidation(projectRoot = process.cwd(), mode = 'public') {
+  const counts = countWikiMetabolismEntries(projectRoot, mode);
+  return writeWikiMetabolismMarker(projectRoot, counts);
+}
+
+function validateAgentReadableWikiPages(projectRoot = process.cwd(), mode = 'public', options = {}) {
   const findings = [];
   const pages = readWikiPages(projectRoot, mode);
   const stalePages = new Set(findStaleWikiPages(projectRoot, mode).map((item) => item.page));
@@ -609,9 +731,12 @@ function validateAgentReadableWikiPages(projectRoot = process.cwd(), mode = 'pub
     }
   }
 
+  findings.push(...findWikiMetabolismFindings(projectRoot, mode, options.budgets));
+
   return {
     ok: findings.length === 0,
     pageCount: pages.length,
+    surfaceCounts: countWikiMetabolismEntries(projectRoot, mode),
     findingCount: findings.length,
     findings,
   };
@@ -802,18 +927,29 @@ Output:
 - No hedging if the wiki is stale or messy`;
 }
 
+function buildConsolidatePrompt(mode = 'public') {
+  const wikiRoot = getWikiRoot(mode);
+  return `Atris wiki consolidation pass
+
+Read ${wikiRoot}/index.md, ${wikiRoot}/log.md, and every page under the wiki subfolders.
+
+Pruning rules:
+- UPDATE facts that changed.
+- DELETE stale facts, duplicates, and mechanics.
+- ADD nothing new.
+
+Keep rules:
+- Entries marked as user-stated conventions or explicit remember-this survive.
+- Every kept entry keeps its provenance as a source link or date.
+
+Consolidate overlapping entries, preserve the strongest source-backed version, and leave index.md and page links consistent.`;
+}
+
 module.exports = {
   WIKI_ROOT,
-  CONTEXT_ROOT,
   PRIVATE_WIKI_ROOT,
-  PRIVATE_CONTEXT_ROOT,
-  LEGACY_WIKI_ROOT,
-  WIKI_SUBDIRS,
-  WIKI_CONTENT_SUBDIRS,
-  WIKI_SCHEMA: buildWikiSchema(),
-  WIKI_STATUS_FILE,
+  WIKI_METABOLISM_MARKER,
   getWikiRoot,
-  getContextRoot,
   ensureWikiScaffold,
   ensureContextScaffold,
   findLocalWikiDir,
@@ -822,6 +958,12 @@ module.exports = {
   readWikiPages,
   findStaleWikiPages,
   findWikiOrphans,
+  countWikiMetabolismEntries,
+  readWikiMetabolismMarker,
+  writeWikiMetabolismMarker,
+  findWikiMetabolismFindings,
+  wikiMetabolismNudge,
+  recordWikiConsolidation,
   validateAgentReadableWikiPages,
   findSuggestedSources,
   stageWikiIngest,
@@ -830,4 +972,5 @@ module.exports = {
   buildIngestPrompt,
   buildQueryPrompt,
   buildLintPrompt,
+  buildConsolidatePrompt,
 };

package/lib/wish-audit.js

@@ -167,7 +167,7 @@ const BUDGET_LABELS = {
 const WISH_SWEEP_LIMIT = 3;
 const WISH_MISSION_RUNNER = 'claude';
 const TEST_VERIFY_COMMAND = 'node --test';
-const JOURNAL_RESULT_TEXT = 'a written result will be waiting in your journal';
+const JOURNAL_RESULT_TEXT = 'the wish is recorded and the result comes back for review';
 const WAITING_INPUT_STATUSES = new Set(['needs_input', 'waiting_input']);
 const PATH_SLOT_QUESTION = 'Where should I find the file or folder you named?';
 const AUDIENCE_WORDS = /\b(?:for|user|users|customer|customers|operator|operators|agent|agents|developer|developers|admin|admins|member|members|team|teams|visitor|visitors|client|clients|student|students|founder|founders|newcomer|newcomers)\b/i;
@@ -490,6 +490,24 @@ function resolveRole(role, root) {
   return resolver(role, root);
 }
 
+// Route-time validator policy: the routing decision must not depend on which
+// validator binaries happen to exist on this machine. Prefer a ready distinct
+// validator, else fall back to the registry's policy order; the dispatch
+// flight reports an honest validator failure if the engine is still missing
+// when validation actually runs.
+function policyValidator(root, excludeId = '') {
+  try {
+    const ranked = engineRegistry.engineRegistryView(root)
+      .filter((engine) => engine.roles.includes('validator'))
+      .filter((engine) => engine.id !== String(excludeId || ''))
+      .sort((a, b) => Number(a.fallback_order) - Number(b.fallback_order)
+        || String(a.id).localeCompare(String(b.id)));
+    return ranked.find((engine) => engine.health && engine.health.status === 'ready') || ranked[0] || null;
+  } catch {
+    return null;
+  }
+}
+
 function resolveExecutor(root, engineOverride = '') {
   if (engineOverride) {
     return engineRegistry.resolveEngineForRoleWithPreference('executor', root, engineOverride);
@@ -1239,7 +1257,8 @@ function auditWish(text, root = process.cwd(), options = {}) {
     const question = 'Which working reviewer should validate it?';
     const answered = answeredRepeatedQuestionValue(text, root, question, 'reviewer');
     if (answered) validator = { id: slugify(answered), name: answered };
-    else questions.push(question);
+    else if (options.assumeValidator) validator = policyValidator(root, executor && executor.id);
+    if (!validator) questions.push(question);
   }
 
   let missing = missingNamedInputs(originalText, root);
@@ -1346,9 +1365,6 @@ function verifyOutcomeText(planOrCommand) {
 }
 
 module.exports = {
-  BUDGET_LABELS,
-  JOURNAL_RESULT_TEXT,
-  TEST_VERIFY_COMMAND,
   WAITING_INPUT_STATUSES,
   WISH_MISSION_RUNNER,
   WISH_SWEEP_LIMIT,
@@ -1357,8 +1373,6 @@ module.exports = {
   deriveVerifyPlan,
   inferBudgetTier,
   missingNamedInputs,
-  namedTestFiles,
-  PATH_SLOT_QUESTION,
   quoteText,
   sharesMeaningfulWords,
   validateEngineOverride,