atris 3.37.0 → 3.38.0

package/commands/task.js

@@ -17,6 +17,7 @@ const {
   runVerifyCommandCached,
   DENIED_TAGS,
 } = require('../lib/auto-accept-certified');
+const { evaluateAcceptVerify } = require('../lib/accept-verify-gate');
 const { extractReceiptEvidence, RECEIPT_PATH_PATTERN } = require('../lib/receipt-evidence');
 const escapeRegExp = require('../lib/escape-regexp');
 const reviewIntegrity = require('../lib/review-integrity');
@@ -880,10 +881,15 @@ function certifiedReviewNextAction(nextTaskTitle) {
 function proofBoundaryBlockedEvaluation(task) {
   const missionXpBoundary = missionXpProofBoundaryEvaluation(task);
   if (missionXpBoundary) return missionXpBoundary;
-  // strictVerify stays off here: this is a render-path probe for the boundary
-  // reason only, and the default-true strict mode would spawn the verify
-  // subprocess for every certified row just to draw the desk.
-  const evaluation = evaluateAutoAccept(task, { strictVerify: false, minPasses: 0 });
+  // This is a render-path probe for the boundary reason only. strictVerify
+  // alone is not enough to keep it read-only because probationary actors
+  // still require strict verification. Never execute a stored verifier while
+  // drawing task reviews, status, queues, or projections.
+  const evaluation = evaluateAutoAccept(task, {
+    strictVerify: false,
+    minPasses: 0,
+    executeVerify: false,
+  });
   return evaluation && evaluation.reason === 'proof_unmerged_or_draft_pr_boundary'
     ? evaluation
     : null;
@@ -1583,9 +1589,74 @@ function enrichTaskProjection(projection) {
     },
     streams: buildTaskStreams(enrichedTasks, goalSource.goals),
     tasks: enrichedTasks,
+    missions: projectionMissions(root),
+    wishes: projectionWishes(root),
   };
 }
 
+// The desktop app renders projection.missions but the writer never filled it,
+// so live workers were invisible on every dashboard. Best-effort: a broken
+// mission or wish store must never take the task projection down with it.
+const PROJECTION_MISSION_LIMIT = 50;
+const PROJECTION_WISH_LIMIT = 30;
+const PROJECTION_CLIP = 240;
+
+function clipForProjection(value) {
+  const text = String(value || '');
+  return text.length > PROJECTION_CLIP ? `${text.slice(0, PROJECTION_CLIP - 3)}...` : text;
+}
+
+function projectionMissions(root) {
+  try {
+    const { listMissions } = require('./mission.js');
+    const recentCutoff = Date.now() - 48 * 60 * 60 * 1000;
+    return listMissions(root)
+      .filter(mission => {
+        const status = String(mission.status || '');
+        if (!['complete', 'stopped'].includes(status)) return true;
+        const updated = Date.parse(mission.updated_at || mission.created_at || '') || 0;
+        return updated >= recentCutoff;
+      })
+      .slice(0, PROJECTION_MISSION_LIMIT)
+      .map(mission => ({
+        id: mission.id,
+        objective: clipForProjection(String(mission.objective || '')),
+        status: mission.status || null,
+        owner: mission.owner || null,
+        runner: mission.runner || null,
+        cadence: mission.cadence || null,
+        lane: mission.lane || null,
+        next_action: clipForProjection(String(mission.next_action || '')),
+        last_tick_at: mission.last_tick_at || null,
+        last_tick_status: mission.last_tick_status || null,
+        receipt_path: mission.receipt_path || null,
+        wish_id: mission.wish_id || null,
+        created_at: mission.created_at || null,
+        updated_at: mission.updated_at || null,
+      }));
+  } catch {
+    return [];
+  }
+}
+
+function projectionWishes(root) {
+  try {
+    const { readWishes } = require('../lib/wish-store');
+    return readWishes(root)
+      .filter(wish => String(wish.status || '') !== 'closed')
+      .slice(-PROJECTION_WISH_LIMIT)
+      .map(wish => ({
+        id: wish.id,
+        n: wish.n ?? null,
+        text: clipForProjection(String(wish.text || '')),
+        status: wish.status || null,
+        created_at: wish.first_ts || wish.ts || null,
+      }));
+  } catch {
+    return [];
+  }
+}
+
 function taskTypeForCloud(task) {
   const tag = String(task.tag || '').toLowerCase();
   if (['inbound', 'outbound', 'creative', 'improvement'].includes(tag)) return tag;
@@ -5442,19 +5513,17 @@ function taskReviewLandingLines(item) {
 function cmdReviews(args) {
   const taskDb = getTaskDb();
   const db = taskDb.open();
-  let { projection, outPath } = writeDefaultProjection(taskDb, db);
-  const workspaceRoot = projection.workspace_root || process.cwd();
-  const previousAutoAcceptState = readReviewAutoAcceptState(workspaceRoot);
-  const autoAcceptRun = autoAcceptCertifiedSmallReviews(taskDb, db, projection);
-  if (autoAcceptRun.changed) {
-    ({ projection, outPath } = writeDefaultProjection(taskDb, db));
-  }
-  const autoAcceptRollup = reviewAutoAcceptRollup(taskDb, db, workspaceRoot, previousAutoAcceptState, autoAcceptRun);
-  writeReviewAutoAcceptState(workspaceRoot, {
-    ...previousAutoAcceptState,
-    last_look_at: new Date().toISOString(),
-    last_count: autoAcceptRollup.count,
-  });
+  const { projection, outPath } = writeDefaultProjection(taskDb, db);
+  // Reviews is a view, not an execution lane. Certification and landing are
+  // persisted by certify-verified, explicit receipt/ready commands, sweep,
+  // and autoland; this command only reports that stored state.
+  const autoAcceptView = {
+    enabled: false,
+    read_only: true,
+    accepted_now: 0,
+    accepted_since_last_look: 0,
+    results: [],
+  };
   const groupByRaw = flag(args, '--group-by');
   if (groupByRaw) {
     const key = reviewGroupKey(groupByRaw);
@@ -5464,20 +5533,12 @@ function cmdReviews(args) {
         ok: true,
         action: 'review_groups',
         projection_path: outPath,
-        autoaccept: {
-          enabled: autoAcceptRun.enabled,
-          accepted_now: autoAcceptRun.accepted,
-          accepted_since_last_look: autoAcceptRollup.count,
-          results: autoAcceptRun.results,
-        },
+        autoaccept: autoAcceptView,
         groups,
       });
       return;
     }
     console.log(gateForHuman(`${numberWord(groups.total_certified)} finished things are waiting, grouped by ${key}.`).text);
-    if (autoAcceptRollup.count > 0) {
-      console.log(gateForHuman(`${numberWord(autoAcceptRollup.count)} landed on their own since you last looked.`).text);
-    }
     const visibleGroups = groups.groups.slice(0, reviewGroupTextLimit(args, groups.groups.length));
     visibleGroups.forEach((g, index) => {
       console.log('');
@@ -5498,12 +5559,7 @@ function cmdReviews(args) {
       ok: true,
       action: 'review_queue',
       projection_path: outPath,
-      autoaccept: {
-        enabled: autoAcceptRun.enabled,
-        accepted_now: autoAcceptRun.accepted,
-        accepted_since_last_look: autoAcceptRollup.count,
-        results: autoAcceptRun.results,
-      },
+      autoaccept: autoAcceptView,
       queue,
     });
     return;
@@ -5512,9 +5568,6 @@ function cmdReviews(args) {
   const blockedItems = queue.items.filter(item => item.queue_role === 'blocked');
   if (!approvalItems.length && !blockedItems.length) {
     console.log('nothing is waiting on you. everything that finished has already landed.');
-    if (autoAcceptRollup.count > 0) {
-      console.log(gateForHuman(`${numberWord(autoAcceptRollup.count)} landed on their own since you last looked.`).text);
-    }
     return;
   }
   if (queue.counts.certified > 0) {
@@ -5528,12 +5581,13 @@ function cmdReviews(args) {
       ? 'one more is almost ready; a second check is still running.'
       : `${numberWord(queue.counts.blocking)} more are almost ready; second checks are still running.`).text);
   }
-  if (autoAcceptRollup.count > 0) {
-    console.log(gateForHuman(`${numberWord(autoAcceptRollup.count)} landed on their own since you last looked.`).text);
-  }
   approvalItems.forEach((item, index) => {
     if (index > 0) console.log('');
-    console.log(`${index + 1}. ${gateForHuman(item.title, { title: item.title }).text}`);
+    const ref = item.display_id || taskRef(item.id);
+    const badge = item.evidence?.any_forced
+      ? ' [evidence:forced]'
+      : item.evidence?.all_passing ? ' [evidence:passing]' : '';
+    console.log(`${index + 1}. ${gateForHuman(item.title, { title: item.title }).text} (${ref})${badge}`);
     if (item.landing) {
       taskReviewLandingLines(item).forEach(line => console.log(line));
       if (verbose && item.result?.saved) console.log(`   saved: ${item.result.saved}`);
@@ -9436,6 +9490,28 @@ async function cmdAccept(args) {
   if (missionXpIssue) {
     failTask('atris task accept', MISSION_XP_END_TO_END_REASON, missionXpIssue);
   }
+  // The proof must be able to fail. Run the stored verify command and refuse the
+  // accept if it does not parse, does not run, or does not pass. Prose describing a
+  // check is not a check.
+  const acceptVerify = evaluateAcceptVerify(beforeTask, taskDb.workspaceRoot());
+  const verifyOverride = hasFlag(args, '--accept-unverified');
+  const overrideReason = String(flag(args, '--reason') || '').trim();
+  if (!acceptVerify.ok && !verifyOverride) {
+    failTask(
+      'atris task accept',
+      acceptVerify.reason,
+      `${acceptVerify.detail}. Stored verify: ${acceptVerify.command || '(none)'}. `
+        + 'Fix the verify command and re-run, or accept deliberately with '
+        + '--accept-unverified --reason "why this cannot be machine-checked".',
+    );
+  }
+  if (!acceptVerify.ok && verifyOverride && !overrideReason) {
+    failTask(
+      'atris task accept',
+      'unverified_accept_needs_reason',
+      '--accept-unverified records an unfalsifiable accept in the ledger, so it requires --reason "<why>".',
+    );
+  }
   const readyReview = beforeTask?.review || {};
   const clearLesson = hasEmptyFlagValue(args, '--lesson');
   const clearNextTask = hasEmptyFlagValue(args, '--next');
@@ -9923,11 +9999,19 @@ function cmdAutoAcceptCertified(args) {
     }
     const landingVerify = reverifyBeforeLanding(taskDb, db, task, { verifyCache });
     if (!landingVerify.ok) {
+      // A refused landing whose revise also failed is the worst state in the
+      // loop: the work does not land AND nobody is told to fix it, so the row
+      // sits in review forever being re-refused every hour. Mark it so the
+      // heartbeat can raise it instead of counting it as routine.
       results.push({
         ...evaluation,
         eligible: false,
         action: landingVerify.revised ? 'revised' : 'revise_failed',
         reason: landingVerify.result.reason || landingVerify.revise_reason || 'verify_failed',
+        ...(landingVerify.result.unrunnable_cause
+          ? { unrunnable_cause: landingVerify.result.unrunnable_cause }
+          : {}),
+        alarm: landingVerify.revised !== true || landingVerify.result.reason === 'verify_unrunnable',
         verify: landingVerify.verify,
         exit_code: landingVerify.result.status,
         revision_note: landingVerify.note,
@@ -12261,4 +12345,6 @@ module.exports = {
   delegateTask,
   AGENT_ENV_MARKERS,
   autoRenderTodoFromDb,
+  projectionMissions,
+  projectionWishes,
 };

package/commands/teach.js

@@ -0,0 +1,86 @@
+'use strict';
+
+/**
+ * atris teach — turn one bad turn into a permanent guard.
+ *
+ *   atris teach                          list cases and which ones are guards
+ *   atris teach add --id <id> --prompt "…" --require "<fragment>" [--complaint "…"]
+ *   atris teach run [<id>]               run one case (or all) and advance state
+ *   atris teach guards                   rerun every promoted guard (regression suite)
+ *
+ * Thin shim over `python -m rl.teach` in the backend venv, which owns the
+ * red gate: a case must be observed FAILING before it can become a guard.
+ * Nonzero exit means a guard regressed.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const BACKEND_ROOT = '/Users/keshavrao/arena/atrisos-backend';
+
+function requireVenvPython() {
+  const venvPython = path.join(BACKEND_ROOT, 'venv/bin/python');
+  if (!fs.existsSync(venvPython)) {
+    console.error(`✗ Backend venv not found: ${venvPython}`);
+    process.exit(1);
+  }
+  return venvPython;
+}
+
+function usage() {
+  console.log('atris teach — a bad turn becomes a failing benchmark, then a guard');
+  console.log('');
+  console.log('  atris teach                  list cases (red = not yet fixed, guard = protected)');
+  console.log('  atris teach add …            record a misbehavior as a red case');
+  console.log('  atris teach run [<id>]       run a case; a red case is SUPPOSED to fail');
+  console.log('  atris teach guards           rerun every guard; nonzero exit = regression');
+  console.log('  atris teach drafts           corrections captured from live turns');
+  console.log('  atris teach fix <id>         brief a fix for a reproduced case (--dispatch to run it)');
+  console.log('  atris teach scaffold …       turn a captured correction into a red case');
+  console.log('  atris teach mine             which recorded tick failures could become cases');
+  console.log('');
+  console.log('  add flags: --id <kebab> --prompt "…" --require "<fragment>" (repeatable)');
+  console.log('             --complaint "…" --file path=@localfile --forbid-changed-files');
+}
+
+/**
+ * Map the operator-facing verbs onto `python -m rl.teach` arguments.
+ * Returns null for help.
+ */
+function buildArgs(subcommand, args) {
+  if (!subcommand || subcommand === 'list') return ['list'];
+  if (subcommand === 'help' || subcommand === '--help' || subcommand === '-h') return null;
+  if (subcommand === 'add') return ['add', ...args];
+  if (subcommand === 'guards') return ['run', '--guards', ...args];
+  if (subcommand === 'mine') return ['mine', ...args];
+  if (subcommand === 'drafts') return ['drafts', ...args];
+  if (subcommand === 'fix') {
+    // `atris teach fix <id>` -> `fix --case <id>`
+    if (args.length && !args[0].startsWith('-')) return ['fix', '--case', args[0], ...args.slice(1)];
+    return ['fix', ...args];
+  }
+  if (subcommand === 'scaffold') return ['scaffold', ...args];
+  if (subcommand === 'run') {
+    // `atris teach run <id>` -> `run --case <id>`; bare `run` runs every case.
+    if (args.length && !args[0].startsWith('-')) return ['run', '--case', args[0], ...args.slice(1)];
+    return ['run', ...args];
+  }
+  // `atris teach <id>` is shorthand for running that one case.
+  if (!subcommand.startsWith('-')) return ['run', '--case', subcommand, ...args];
+  return null;
+}
+
+module.exports = function teach(subcommand, ...args) {
+  const moduleArgs = buildArgs(subcommand, args);
+  if (moduleArgs === null) {
+    usage();
+    return;
+  }
+  const result = spawnSync(requireVenvPython(), ['-m', 'rl.teach', ...moduleArgs], {
+    cwd: path.join(BACKEND_ROOT, 'backend'),
+    stdio: 'inherit',
+  });
+  process.exit(result.status === null ? 1 : result.status);
+};
+

package/commands/unknowns.js

@@ -613,15 +613,5 @@ async function unknownsCommand(args = []) {
 module.exports = {
   unknownsCommand,
   showHelp,
-  ensureUnknownsSchema,
-  gatherTerritoryContext,
-  buildUnknownsPrompt,
-  analyzeWithModel,
-  normalizeUnknowns,
-  normalizeQuestions,
   fallbackPayload,
-  insertUnknowns,
-  listUnknownRows,
-  renderUnknownsMarkdown,
-  resolveUnknown,
 };

package/commands/update.js

@@ -40,5 +40,4 @@ function updateSelf(options = {}) {
 
 module.exports = {
   updateSelf,
-  DEFAULT_PACKAGE_ROOT,
 };

package/commands/visualize.js

@@ -389,9 +389,4 @@ async function visualizeAtris(args = process.argv.slice(3)) {
 
 module.exports = {
   visualizeAtris,
-  parseVisualizeArgs,
-  buildImagePrompt,
-  classifyArtifact,
-  resolveOutputPath,
-  generateVisual,
 };

package/commands/watch.js

@@ -293,11 +293,5 @@ function watchAtris() {
 
 module.exports = {
   watchAtris,
-  watchCommand,
-  showWatchHelp,
   slugify,
-  buildWatchObjective,
-  activeWatchMissions,
-  resolveWatchMission,
-  watchStatePath,
 };

package/commands/wiki.js

@@ -14,8 +14,11 @@ const {
   buildIngestPrompt,
   buildQueryPrompt,
   buildLintPrompt,
+  buildConsolidatePrompt,
   writeWikiStatus,
   appendWikiLog,
+  findWikiMetabolismFindings,
+  recordWikiConsolidation,
   validateAgentReadableWikiPages,
 } = require('../lib/wiki');
 
@@ -171,7 +174,7 @@ function hasHelpFlag(args) {
 }
 
 function printWikiHelp(scope = null) {
-  const normalized = scope === 'ingest' || scope === 'query' || scope === 'lint' || scope === 'search' || scope === 'log' || scope === 'loop' || scope === 'verify'
+  const normalized = scope === 'ingest' || scope === 'query' || scope === 'lint' || scope === 'consolidate' || scope === 'search' || scope === 'log' || scope === 'loop' || scope === 'verify'
     ? scope
     : null;
 
@@ -191,12 +194,17 @@ function printWikiHelp(scope = null) {
     console.log('Usage: atris wiki lint [--private|--cloud] [business]');
     console.log('');
     console.log('Build a local or cloud wiki lint prompt.');
+  } else if (normalized === 'consolidate') {
+    console.log('Usage: atris wiki consolidate [--private]');
+    console.log('');
+    console.log('Build a local wiki pruning prompt and reset the growth marker.');
   } else {
-    console.log('Usage: atris wiki <ingest|query|lint|search|log|loop|verify|entities|related> [business] [args]');
+    console.log('Usage: atris wiki <ingest|query|lint|consolidate|search|log|loop|verify|entities|related> [business] [args]');
     console.log('');
     console.log('  ingest <path>                 Local-first ingest into atris/wiki/');
     console.log('  query  "question"             Local-first query against atris/wiki/');
     console.log('  lint                          Local-first lint for atris/wiki/');
+    console.log('  consolidate                   Build a local pruning prompt and reset wiki growth');
     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');
@@ -366,7 +374,11 @@ async function wikiLint(mode, slug) {
       console.error(`No local wiki found at ${getWikiRoot(wikiMode)}. Run: atris wiki ingest${wikiMode === 'private' ? ' --private' : ''} <path>`);
       process.exit(1);
     }
-    printLocalPrompt(mode === 'private' ? 'Private wiki lint' : 'Local wiki lint', buildLintPrompt(wikiMode), getWikiRoot(wikiMode), [`Wiki dir: ${wikiDir}`]);
+    const metabolismFindings = findWikiMetabolismFindings(process.cwd(), wikiMode);
+    printLocalPrompt(mode === 'private' ? 'Private wiki lint' : 'Local wiki lint', buildLintPrompt(wikiMode), getWikiRoot(wikiMode), [
+      `Wiki dir: ${wikiDir}`,
+      ...metabolismFindings.map((finding) => `${finding.code}: ${finding.message}`),
+    ]);
     return;
   }
 
@@ -376,6 +388,28 @@ async function wikiLint(mode, slug) {
   await runChat(business, buildLintPrompt(), creds.token);
 }
 
+function wikiConsolidate(mode, slug) {
+  if (mode === 'cloud') {
+    console.error('Wiki consolidation is local-only. Pull the wiki before consolidating it.');
+    process.exit(1);
+  }
+
+  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);
+  }
+
+  printLocalPrompt(
+    mode === 'private' ? 'private wiki consolidate' : 'local wiki consolidate',
+    buildConsolidatePrompt(wikiMode),
+    getWikiRoot(wikiMode),
+    [`wiki dir: ${wikiDir}`]
+  );
+  recordWikiConsolidation(process.cwd(), wikiMode);
+}
+
 function wikiSearch(mode, slug, query) {
   if (!query) {
     console.error('Usage: atris wiki search [business] <term>');
@@ -513,6 +547,10 @@ async function wikiCommand(subcommand, ...args) {
       await wikiLint(mode, slug);
       break;
     }
+    case 'consolidate': {
+      wikiConsolidate(mode, null);
+      break;
+    }
     case 'search': {
       if (mode === 'private') {
         wikiSearch(mode, null, cleanArgs.join(' '));
@@ -572,12 +610,4 @@ async function wikiCommand(subcommand, ...args) {
 
 module.exports = {
   wikiCommand,
-  wikiIngest,
-  wikiQuery,
-  wikiLint,
-  wikiSearch,
-  wikiLog,
-  wikiVerify,
-  wikiEntities,
-  wikiRelated,
 };

package/commands/wish.js

@@ -487,7 +487,6 @@ module.exports = {
   printRewards,
   readWishEvents,
   readWishes,
-  runCloudWish,
   runAgainWish,
   sayWish,
   sharesMeaningfulWords,