atris 3.58.5 → 3.58.7

package/commands/mission.js

@@ -6,6 +6,7 @@ const crypto = require('crypto');
 const readline = require('readline');
 const { spawn, spawnSync } = require('child_process');
 const { hasFlag, readFlag, readIntFlag } = require('../lib/arg-parser');
+const { memberProcessPrompt } = require('../lib/member-context');
 const {
   compactErrorPayload,
   compactSuccessPayload,
@@ -111,6 +112,15 @@ const CODEX_NATIVE_GOAL_CLOSED_STATUSES = new Set(['complete', 'completed', 'ach
 const DEFAULT_LONG_RUN_VERIFIER = 'git diff --check';
 const SLEEP_LENGTH_BUDGET_SECONDS = 3600;
 const HUMAN_BLOCKING_PAUSE_REASONS = new Set(['auth-required', 'model-unavailable', 'rate-limit-exceeded-wall']);
+// Claude prints its logged-out message on stdout ("Invalid API key · Please
+// run /login"), not stderr, so the check has to read the captured result text
+// too or a dead login masquerades as a generic claude-error.
+const MISSION_RUNNER_AUTH_EXPIRED_RE = /not authenticated|please log in|login required|auth(?:entication)? expired|invalid (?:api|connection) key|run \/login/i;
+
+function missionRunnerAuthExpired(...texts) {
+  return texts.some((text) => Boolean(text) && MISSION_RUNNER_AUTH_EXPIRED_RE.test(String(text)));
+}
+
 const MISSION_BUDGET_TIERS = Object.freeze({
   quick: Object.freeze({ max_ticks: 4, requested_seconds: 15 * 60 }),
   long: Object.freeze({ max_ticks: 12, requested_seconds: 60 * 60 }),
@@ -8406,8 +8416,12 @@ function probeClaudeBinary() {
 // Pull unread operator pings off the mission and mark them consumed, so the
 // next tick's prompt carries them exactly once. Pings are how a human talks to
 // an always-on member mid-run: atris member ping <name> "<msg>".
+function pendingMissionPings(mission) {
+  return (Array.isArray(mission.pings) ? mission.pings : []).filter((p) => p && !p.consumed_at);
+}
+
 function consumeMissionPings(mission, cwd) {
-  const pending = (Array.isArray(mission.pings) ? mission.pings : []).filter((p) => p && !p.consumed_at);
+  const pending = pendingMissionPings(mission);
   if (!pending.length) return { mission, pings: [] };
   const consumedAt = stampIso();
   const pings = (mission.pings || []).map((p) => (p && !p.consumed_at ? { ...p, consumed_at: consumedAt } : p));
@@ -8415,7 +8429,8 @@ function consumeMissionPings(mission, cwd) {
   return { mission: saved, pings: pending };
 }
 
-function buildTickPrompt(mission, tickIndex, maxTicks, frozen, pings = []) {
+function buildTickPrompt(mission, tickIndex, maxTicks, frozen, pings = [], cwd = process.cwd()) {
+  const sharedProcess = memberProcessPrompt(cwd);
   const pingLines = pings.length
     ? [
       ``,
@@ -8447,6 +8462,7 @@ function buildTickPrompt(mission, tickIndex, maxTicks, frozen, pings = []) {
     `**Last tick:** ${mission.last_tick_at || 'never'}`,
     ...missionBudgetPromptLines(mission),
     ...checkFeedbackLines,
+    ...(sharedProcess ? ['', sharedProcess] : []),
     ``,
     `## Your task`,
     `Do ONE increment of work toward the stop condition. ONE. No more.`,
@@ -8765,7 +8781,7 @@ function spawnGenericRunnerTick(mission, opts) {
       const finalText = String(stdout || '').trim();
       const errStr = String(stderr || '').slice(-2000);
       const ok = code === 0 && !timedOut && !aborted;
-      const authExpired = /not authenticated|please log in|login required|auth(?:entication)? expired/i.test(errStr);
+      const authExpired = !ok && missionRunnerAuthExpired(errStr, finalText);
       resolve({
         ok,
         brief_id: briefId,
@@ -8940,7 +8956,7 @@ function spawnClaudeTick(mission, opts) {
       updateMissionLockOwner(missionLock, missionLock?.driverPid);
       const ok = code === 0 && !isError && !timedOut && !aborted;
       const errStr = stderr.slice(-2000);
-      const authExpired = /not authenticated|please log in|login required|auth(?:entication)? expired/i.test(errStr);
+      const authExpired = !ok && missionRunnerAuthExpired(errStr, finalText, stdoutBuf);
       resolve({
         ok,
         timedOut,
@@ -9521,6 +9537,9 @@ async function executeMissionRunTicksPhase(context) {
           drill: drillResult,
         };
       } else if (tickAtris2Runner) {
+        // Build before consuming direction or allocating the guard: a shared
+        // process read error must leave operator pings available for retry.
+        const prompt = buildTickPrompt(tickRuntimeMission, tickIdx, effectiveMaxTicks, frozen, pendingMissionPings(mission), cwd);
         let atris2GitGuard = null;
         try {
           atris2GitGuard = prepareMissionGitGuard({ root: cwd, tags: missionProtectedTags(mission, cwd) });
@@ -9541,7 +9560,6 @@ async function executeMissionRunTicksPhase(context) {
           const pingDrain = consumeMissionPings(mission, cwd);
           mission = pingDrain.mission;
           runtimeMission = runtimeView(mission);
-          const prompt = buildTickPrompt(tickRuntimeMission, tickIdx, effectiveMaxTicks, frozen, pingDrain.pings);
           const { runAtris2Turn } = require('./probe');
           const businessId = businessIdForAtris2Mission(tickRuntimeMission, cwd);
           const tickController = new AbortController();
@@ -9593,12 +9611,12 @@ async function executeMissionRunTicksPhase(context) {
           }
         }
       } else {
+        const prompt = buildTickPrompt(tickRuntimeMission, tickIdx, effectiveMaxTicks, frozen, pendingMissionPings(mission), cwd);
         let sessionMode = sessionId ? 'resume' : 'set';
         let useId = sessionId || pendingSessionId;
         const pingDrain = consumeMissionPings(mission, cwd);
         mission = pingDrain.mission;
         runtimeMission = runtimeView(mission);
-        const prompt = buildTickPrompt(tickRuntimeMission, tickIdx, effectiveMaxTicks, frozen, pingDrain.pings);
         const restoreTickRunnerProfile = tickEngineId ? applyMissionRunnerProfile(tickEngineId) : () => {};
         let claudeResult;
         let sessionBusyRetried = false;
@@ -9813,6 +9831,14 @@ async function executeMissionRunTicksPhase(context) {
       const claudeRanTick = Boolean(result.claude) && result.status === 'ran';
       const claudeSessionTicks = claudeRanTick ? Number(mission.claude_session_ticks || 0) + 1 : Number(mission.claude_session_ticks || 0);
       const rotateSessionForContext = claudeRanTick && claudeSessionTicks >= CLAUDE_SESSION_CONTEXT_ROTATE_TICKS;
+      // Heartbeat missions run one tick per invocation, so the in-run ticks
+      // array alone can never see two identical errors. Persist the trailing
+      // same-reason errored count so the breaker below trips across runs.
+      const errorStreakCount = result.status === 'errored' && result.reason
+        ? (latestOnDisk.last_tick_status === 'errored' && latestOnDisk.last_tick_reason === result.reason
+          ? Number(latestOnDisk.error_streak_count || 0) + 1
+          : 1)
+        : 0;
       // Base on latestOnDisk so mid-tick complete proof/completed_at survive.
       mission = saveMission({
         ...latestOnDisk,
@@ -9825,6 +9851,7 @@ async function executeMissionRunTicksPhase(context) {
         last_tick_index: tickIdx,
         last_tick_layer: result.layer,
         last_tick_layer_source: result.layer_source,
+        error_streak_count: errorStreakCount,
         verifier_result: verifierResult || (verifyEach && result.protected_lane_guard && result.protected_lane_guard.allowed === false ? null : latestOnDisk.verifier_result) || null,
         last_check_feedback: verifierResult
           ? extractCheckFeedback(verifierResult)
@@ -9902,9 +9929,12 @@ async function executeMissionRunTicksPhase(context) {
       // is the same trap one step less deterministic: keep retrying and the loop burns every
       // tick + cron firing on it. Halt at two-in-a-row and surface the reason for a human.
       const errStreak = consecutiveSameReasonErrors(ticks);
+      // The in-run ticks array only sees this invocation; the persisted streak
+      // carries identical errors across heartbeat runs of one tick each.
+      const errStreakCount = Math.max(errStreak.count, errStreak.reason ? Number(mission.error_streak_count || 0) : 0);
       // Sleeping Atris2 backends are different: leave the mission running so the
       // next tick or heartbeat can catch the backend after it wakes.
-      if (errStreak.count >= 2 && !missionRunKeepsRetryingError(errStreak.reason)) { pauseReason = `repeated-error:${errStreak.reason}`; break; }
+      if (errStreakCount >= 2 && !missionRunKeepsRetryingError(errStreak.reason)) { pauseReason = `repeated-error:${errStreak.reason}`; break; }
 
       // Sleep until next tick
       let sleepMs = 0;

package/commands/pulse.js

@@ -18,6 +18,7 @@ const os = require('os');
 const path = require('path');
 const { spawnSync } = require('child_process');
 const pulse = require('../lib/pulse');
+const rsi = require('../lib/rsi-record');
 const { DEFAULT_CLAUDE_RUNNER_MODEL } = require('../lib/runner-command');
 const { hasFlag } = require('../lib/arg-parser');
 
@@ -267,6 +268,14 @@ function tickCommand(args, root = process.cwd()) {
     orbIngestError,
   }));
 
+  // Dream-RSI: record this tick as one attempt when the workspace has the
+  // recorder. Best-effort; a missing or failing recorder never changes the
+  // tick's outcome. The engine spawns claude-backed runners by default.
+  const rsiLog = (m) => { if (!asJson) process.stderr.write(`rsi: ${m}\n`); };
+  const rsiAttempt = rsi.beginAttempt(root, { lane: rsi.IMPROVE_LANE, engine: 'claude', log: rsiLog });
+  const rsiBefore = rsiAttempt ? rsi.gitSnapshot(root) : null;
+  let rsiOutcome = null;
+
   let engine;
   let verify = { passed: null, cmd: verifyCmd };
   try {
@@ -312,6 +321,14 @@ function tickCommand(args, root = process.cwd()) {
         ? 'no due mission; heartbeat alive (no-op)'
         : `mission ${engine.reason}${changedTail}`;
 
+    rsiOutcome = {
+      status: !engine.ok || verify.passed === false ? 'failed' : producedWork ? 'shipped' : 'nothing',
+      verify: verify.passed === true ? 'pass' : verify.passed === false ? 'fail' : 'skipped',
+      elapsed_s: Math.round(elapsedMs / 100) / 10,
+      engine_calls: 1,
+      reason: String(what || '').slice(0, 200),
+    };
+
     const receipt = pulse.buildPulseReceipt({
       tickIndex,
       phase: 'finished',
@@ -426,11 +443,32 @@ function tickCommand(args, root = process.cwd()) {
       orb_policy_lesson: orbPolicy,
     };
     if (orbIngestError) out.orb_ingest_error = orbIngestError;
+    rsiOutcome = {
+      status: 'failed',
+      verify: 'skipped',
+      elapsed_s: Math.round((Date.now() - startedAt) / 100) / 10,
+      engine_calls: 1,
+      reason: String(err && err.message ? err.message : err).slice(-200),
+    };
     if (!asJson) process.stdout.write(`pulse tick #${tickIndex} crashed: ${out.error}\n`);
     return emit(out, asJson);
   } finally {
     process.removeListener('SIGINT', finishInterrupted);
     process.removeListener('SIGTERM', finishInterrupted);
+    if (rsiAttempt) {
+      const delta = rsi.gitDelta(root, rsiBefore);
+      rsi.finishAttempt(root, rsiAttempt, {
+        commits: delta.commits,
+        files: delta.files,
+        ...(rsiOutcome || {
+          status: 'failed',
+          verify: 'skipped',
+          elapsed_s: Math.round((Date.now() - startedAt) / 100) / 10,
+          engine_calls: 1,
+          reason: 'tick ended without an outcome',
+        }),
+      }, { log: rsiLog });
+    }
     pulse.releaseLock(root);
   }
 }

package/commands/rsi.js

@@ -0,0 +1,156 @@
+'use strict';
+
+// atris rsi - read the Dream-RSI attempt ledger in plain words.
+//
+// Prints trees and attempts by lane, the most recent day's attempts and
+// outcomes, the live policy id, and the last dream receipt. Read-only: it
+// never touches record.py, never writes state, and exits 0 even when the
+// workspace has no ledger yet.
+
+const fs = require('fs');
+const rsi = require('../lib/rsi-record');
+
+function readJsonl(file) {
+  try {
+    return fs.readFileSync(file, 'utf8')
+      .split(/\r?\n/)
+      .map((line) => line.trim())
+      .filter(Boolean)
+      .map((line) => { try { return JSON.parse(line); } catch { return null; } })
+      .filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+
+function dayOf(node) {
+  return String((node && node.created_at) || '').slice(0, 10);
+}
+
+function collectStatus(root) {
+  const nodes = rsi.latestNodes(root);
+  const lanes = new Map();
+  for (const n of nodes) {
+    const lane = String(n.lane || 'unknown');
+    if (!lanes.has(lane)) {
+      lanes.set(lane, { trees: new Set(), nodes: 0, shipped: 0, failed: 0, nothing: 0, open: 0 });
+    }
+    const l = lanes.get(lane);
+    l.trees.add(String(n.tree_id || ''));
+    l.nodes += 1;
+    const st = n.outcome && n.outcome.status;
+    if (st === 'shipped') l.shipped += 1;
+    else if (st === 'failed') l.failed += 1;
+    else if (st === 'nothing') l.nothing += 1;
+    else l.open += 1; // running / waiting / unlabeled
+  }
+  const days = [...new Set(nodes.map(dayOf).filter(Boolean))].sort();
+  const lastDay = days.length ? days[days.length - 1] : null;
+  const lastAttempts = lastDay ? nodes.filter((n) => dayOf(n) === lastDay) : [];
+  const policyFile = `${root}/atris/rsi/policy.current`;
+  const policy = fs.existsSync(policyFile) ? rsi.currentPolicyId(root) : 'p-0001 (default)';
+  const dreams = readJsonl(rsi.dreamsPath(root));
+  return {
+    lanes,
+    lastDay,
+    lastAttempts,
+    policy,
+    lastDream: dreams.length ? dreams[dreams.length - 1] : null,
+    totalNodes: nodes.length,
+    ledger: rsi.attemptsPath(root),
+  };
+}
+
+function outcomeWord(status, verify) {
+  if (status === 'shipped') return verify === 'pass' ? 'shipped, verify passed' : 'shipped';
+  if (status === 'failed') return 'failed';
+  if (status === 'nothing') return 'found nothing to do';
+  return 'still open';
+}
+
+function formatStatus(s) {
+  const lines = ['rsi attempts ledger', `  ${s.ledger}`, ''];
+  if (!s.totalNodes) {
+    lines.push('  no attempts recorded yet.');
+    lines.push('');
+    lines.push(`  policy: ${s.policy}`);
+    if (s.lastDream) lines.push(`  last dream: ${dreamLine(s.lastDream)}`);
+    else lines.push('  no dreams yet.');
+    return lines.join('\n');
+  }
+  const totalTrees = [...s.lanes.values()].reduce((a, l) => a + l.trees.size, 0);
+  lines.push(`  ${totalTrees} tree${totalTrees === 1 ? '' : 's'}, ${s.totalNodes} attempt${s.totalNodes === 1 ? '' : 's'} across ${s.lanes.size} lane${s.lanes.size === 1 ? '' : 's'}:`);
+  for (const [lane, l] of [...s.lanes.entries()].sort()) {
+    const parts = [];
+    if (l.shipped) parts.push(`${l.shipped} shipped`);
+    if (l.failed) parts.push(`${l.failed} failed`);
+    if (l.nothing) parts.push(`${l.nothing} nothing`);
+    if (l.open) parts.push(`${l.open} open`);
+    lines.push(`    ${lane}: ${l.trees.size} tree${l.trees.size === 1 ? '' : 's'}, ${l.nodes} attempt${l.nodes === 1 ? '' : 's'}${parts.length ? ` (${parts.join(', ')})` : ''}`);
+  }
+  lines.push('');
+  lines.push(`  last night (${s.lastDay}): ${s.lastAttempts.length} attempt${s.lastAttempts.length === 1 ? '' : 's'}`);
+  for (const n of s.lastAttempts.slice(0, 10)) {
+    const reason = String((n.outcome && n.outcome.reason) || '').replace(/\s+/g, ' ').trim().slice(0, 80);
+    lines.push(`    ${n.id}: ${outcomeWord(n.outcome && n.outcome.status, n.outcome && n.outcome.verify)}${reason ? ` - ${reason}` : ''}`);
+  }
+  if (s.lastAttempts.length > 10) lines.push(`    ...and ${s.lastAttempts.length - 10} more`);
+  lines.push('');
+  lines.push(`  policy: ${s.policy}`);
+  lines.push(s.lastDream ? `  last dream: ${dreamLine(s.lastDream)}` : '  no dreams yet.');
+  return lines.join('\n');
+}
+
+function dreamLine(receipt) {
+  const deployed = receipt.deployed ? `deployed ${receipt.deployed}` : `kept ${receipt.current || 'current policy'}`;
+  const reason = String(receipt.reason || '').replace(/\s+/g, ' ').trim().slice(0, 120);
+  return `${receipt.at || '(no date)'} · ${deployed}${reason ? ` · ${reason}` : ''}`;
+}
+
+function showHelp() {
+  console.log(`atris rsi - read the Dream-RSI attempt ledger
+
+Usage:
+  atris rsi            same as status
+  atris rsi status     trees + attempts by lane, last night's outcomes, policy, last dream
+  atris rsi status --json   machine-readable status
+
+Read-only. State lives in .atris/state/rsi/ (or $ATRIS_RSI_STATE).`);
+}
+
+function run(argv = []) {
+  const args = Array.isArray(argv) ? argv : [];
+  if (args.includes('--help') || args.includes('-h') || args[0] === 'help') {
+    showHelp();
+    return 0;
+  }
+  const sub = args[0] && !args[0].startsWith('-') ? args[0] : 'status';
+  if (sub !== 'status') {
+    console.log(`unknown rsi subcommand: ${sub}`);
+    showHelp();
+    return 2;
+  }
+  const root = process.cwd();
+  const s = collectStatus(root);
+  if (args.includes('--json')) {
+    const lanes = {};
+    for (const [lane, l] of s.lanes.entries()) {
+      lanes[lane] = { trees: l.trees.size, nodes: l.nodes, shipped: l.shipped, failed: l.failed, nothing: l.nothing, open: l.open };
+    }
+    console.log(JSON.stringify({
+      ok: true,
+      ledger: s.ledger,
+      total_nodes: s.totalNodes,
+      lanes,
+      last_day: s.lastDay,
+      last_day_attempts: s.lastAttempts.length,
+      policy: s.policy,
+      last_dream: s.lastDream,
+    }));
+    return 0;
+  }
+  console.log(formatStatus(s));
+  return 0;
+}
+
+module.exports = { run, collectStatus, formatStatus };

package/commands/task.js

@@ -253,6 +253,7 @@ atris task - durable local task state (SQLite, gitignored)
                                            Sweep off-roadmap/duplicate work as archived (not failed);
                                            --from-failed opts in to relabel a fail-closed row (never done)
   atris task clear-done [--before <days>] [--dry-run] [--json]  Archive completed rows, oldest first
+  atris task keep [--json]                 Put away finished and untouched work, then refresh the list
   atris task reap-mission-blockers [--json] Close blocker rows whose missions are complete or stopped
   atris task relabel-archived [--dry-run|--apply]
                                            One-time OBL-1622 migration: relabel June-10 backlog-reset rows failed -> archived
@@ -6416,7 +6417,7 @@ function compactTechnicalDetails(task, formatTitle = value => value) {
 }
 
 function taskDayGroups(tasks, { now = Date.now() } = {}) {
-  const active = tasks.filter(task => task.status !== 'done');
+  const active = tasks.filter(task => task.status !== 'done' && task.status !== 'archived');
   const staleFailed = [];
   const visible = [];
   for (const task of active) {
@@ -6446,7 +6447,43 @@ function taskDayGroups(tasks, { now = Date.now() } = {}) {
   return { groups: grouped, staleFailed };
 }
 
+function refreshKeptTaskList(cwd = process.cwd()) {
+  const taskDb = getTaskDb();
+  const db = taskDb.open();
+  writeDefaultProjection(taskDb, db);
+  autoRenderTodoFromDb(cwd);
+}
+
+function keptCount(result) {
+  return (result && result.put_away ? result.put_away.length : 0)
+    + (result && result.reaped ? result.reaped.length : 0);
+}
+
+function cmdKeep(args) {
+  const result = require('../lib/task-list-keeper').keepWorkspaceTaskList(process.cwd());
+  if (keptCount(result)) refreshKeptTaskList(process.cwd());
+  const count = keptCount(result);
+  if (wantsJson(args)) {
+    printJson({
+      ok: true,
+      action: 'keep',
+      count,
+      put_away: result.put_away,
+      reaped: result.reaped,
+    });
+    return;
+  }
+  if (!count) {
+    console.log('task list is current. nothing to put away.');
+    return;
+  }
+  const noun = count === 1 ? 'item' : 'items';
+  console.log(`put away ${count} ${noun} that were finished or sitting still.`);
+}
+
 function cmdDay(args) {
+  const kept = require('../lib/task-list-keeper').keepWorkspaceTaskList(process.cwd());
+  if (keptCount(kept)) autoRenderTodoFromDb(process.cwd());
   const all = hasFlag(args, '--all');
   const full = hasFlag(args, '--full');
   const everywhere = taskScopeEverywhere(args);
@@ -13321,6 +13358,7 @@ async function runTaskCommand(args) {
     case 'fail':   return cmdDone([...rest, '--failed']);
     case 'archive': return cmdArchive(rest);
     case 'clear-done': return cmdClearDone(rest);
+    case 'keep': return cmdKeep(rest);
     case 'reap-mission-blockers':
     case 'reap-blockers':
       return cmdReapMissionBlockers(rest);
@@ -13425,6 +13463,8 @@ module.exports = {
   delegateTask,
   AGENT_ENV_MARKERS,
   autoRenderTodoFromDb,
+  refreshKeptTaskList,
+  keptCount,
   projectionMissions,
   projectionWishes,
   taskBoardViewModel,

package/commands/workflow.js

@@ -19,6 +19,16 @@ const { startFirstTalk } = require('../lib/context-gatherer');
 const { isNonInteractive } = require('../lib/noninteractive');
 const { loadContext } = require('../lib/state-detection');
 const { buildToolResultBody } = require('../lib/tool-result-encode');
+const { commitReviewLearning } = require('./learn');
+
+function appendReviewLearningToJournal(journalContent, learning) {
+  const text = String(journalContent || '').replace(/\r\n/g, '\n');
+  const note = String(learning || '');
+  if (text.includes('## Notes')) {
+    return text.replace(/## Notes\n/, `## Notes\n${note}\n`);
+  }
+  return `${text}\n## Notes\n${note}\n`;
+}
 
 function wrapWorkflowText(text, width = 76) {
   const normalized = String(text || '').replace(/\s+/g, ' ').trim();
@@ -1774,27 +1784,17 @@ async function reviewAtris() {
           const timestamp = new Date().toLocaleTimeString('en-US', { hour: '2-digit', minute: '2-digit', hour12: false });
           const learning = `- ${timestamp} \u2014 ${answer.trim()}`;
 
-          // Find or create ## Notes section
-          if (journalContent.includes('## Notes')) {
-            journalContent = journalContent.replace(/## Notes\n/, `## Notes\n${learning}\n`);
-          } else {
-            journalContent += `\n## Notes\n${learning}\n`;
-          }
+          journalContent = appendReviewLearningToJournal(journalContent, learning);
 
           fs.writeFileSync(logFile, journalContent);
           console.log('');
           console.log(`✓ Logged to journal: ${learning}`);
         }
 
-        // Also log to structured learnings (if learnings module exists)
         try {
-          const { addLearning } = require('../lib/learnings');
-          const insight = answer.trim();
-          // Auto-classify: starts with "don't" or "never" or "avoid" → pitfall, else pattern
-          const type = /^(don't|never|avoid|watch out|careful)/i.test(insight) ? 'pitfall' : 'pattern';
-          const key = insight.toLowerCase().replace(/[^a-z0-9\s]/g, '').split(/\s+/).slice(0, 4).join('-');
-          addLearning({ type, key, insight, confidence: 7, source: 'review', files: [] });
-          console.log(`✓ Saved to learnings: [7/10] ${type}/${key}`);
+          commitReviewLearning(answer.trim(), {
+            cwd: process.cwd(),
+          });
         } catch {
           // learnings module not available, so skip silently
         }
@@ -1897,6 +1897,7 @@ module.exports = {
   planAtris,
   doAtris,
   reviewAtris,
+  appendReviewLearningToJournal,
   renderReviewMinute,
   executorAgentPrompt,
   executorDispatchForTask,

package/commands/x-search.js

@@ -32,7 +32,7 @@ function showXSearchHelp(output = console.log, commandName = 'atris x-search') {
   output('Prints to stdout. Rich ephemeral prints one apply next-step, then hands off to atris youtube search (no files).');
   output('--save files a brief only when the result is rich.');
   output('unsave deletes the filed brief, apply stub, and matching experiment pack (no paid calls).');
-  output('Empty or failed search refunds the credits.');
+  output('Empty or failed search prints credits refunded only when the server marks a refund.');
   output('');
   output('Options:');
   output('  --limit <n>         Max results hint (search only)');
@@ -327,13 +327,6 @@ function xSearchCredits(data) {
   return { used, remaining, refunded };
 }
 
-function creditsWereRefunded(credits) {
-  if (!credits) return false;
-  if (credits.used === 0) return true;
-  if (credits.refunded === true) return true;
-  return typeof credits.refunded === 'number' && credits.refunded > 0;
-}
-
 function creditsRefundedExplicitly(credits) {
   if (!credits) return false;
   if (credits.refunded === true) return true;
@@ -345,7 +338,7 @@ function formatCreditsLines(credits) {
   if (credits.used !== undefined || credits.remaining !== undefined) {
     lines.push(`Credits: ${credits.used !== undefined ? credits.used : '?'} used, ${credits.remaining !== undefined ? credits.remaining : '?'} remaining`);
   }
-  if (creditsWereRefunded(credits)) {
+  if (creditsRefundedExplicitly(credits)) {
     lines.push('credits refunded');
   }
   return lines;
@@ -360,7 +353,7 @@ function xSearchFailureError(result) {
         ? ' xAI is unavailable; retry in a few seconds.'
         : '';
   const credits = xSearchCredits(result.data);
-  const refundHint = result.status === 502 && creditsWereRefunded(credits)
+  const refundHint = result.status === 502 && creditsRefundedExplicitly(credits)
     ? ' credits refunded.'
     : '';
   const lines = [`X search failed (${result.status}): ${resultErrorText(result)}.${hint}${refundHint}`];
@@ -398,6 +391,12 @@ async function runXSearch(options, deps = {}) {
       forceMint: true,
     });
     if (remint?.ok && remint.token) {
+      if (!options.json) {
+        const print = typeof deps.output === 'function' ? deps.output : () => {};
+        for (const line of formatCreditsLines(xSearchCredits(result.data))) {
+          print(line);
+        }
+      }
       auth = remint;
       result = await call(auth.token);
     }