atris 3.30.12 → 3.32.0

package/lib/next-moves.js

@@ -21,6 +21,27 @@ function norm(title) {
   return String(title == null ? '' : title).trim().toLowerCase();
 }
 
+function titleKey(title) {
+  return norm(String(title == null ? '' : title).replace(/\s+/g, ' ').replace(/^title\s*:\s*/i, ''));
+}
+
+function isGenericInboxPlaceholder(title) {
+  const key = titleKey(title);
+  return /^(dogfood tick|autopilot tick|mission tick|run (one )?tick|tick|test idea|sample idea|placeholder idea|idea|todo|tbd)$/.test(key);
+}
+
+function cleanInboxMoveTitle(title) {
+  const raw = String(title == null ? '' : title).trim();
+  if (!raw) return null;
+  const titleLine = raw.match(/^title\s*:\s*(.+)$/i);
+  if (/^(task|status|action|tag|member|actor|proof|verify|checked|saved|changed|result|files?|commands?)\s*:/i.test(raw)) {
+    return null;
+  }
+  const cleaned = titleLine ? titleLine[1].trim() : raw;
+  if (isGenericInboxPlaceholder(cleaned)) return null;
+  return cleaned;
+}
+
 // Short, stable id so a kill on Tuesday still suppresses the same move on
 // Wednesday. Pure function of (source, title).
 function moveId(source, title) {
@@ -33,7 +54,8 @@ function moveId(source, title) {
   return `m_${(h >>> 0).toString(36)}`;
 }
 
-const WEIGHT = { roadmap: 100, task: 60, inbox: 40 };
+const WEIGHT = { roadmap: 100, mission: 90, endgame: 80, task: 60, inbox: 40 };
+const SELF_IMPROVEMENT_SEED_TITLE = 'Create the next proof-backed self-improvement task';
 
 // One section-boundary shape for every reader and writer: tolerate a header
 // suffix (e.g. "(priority)"), stop at a sibling/parent heading (## or #) or a
@@ -93,17 +115,119 @@ function readActiveTasks(root) {
   const tasks = Array.isArray(proj && proj.tasks) ? proj.tasks : [];
   return tasks
     .filter((t) => t && t.title && ['open', 'claimed'].includes(String(t.status || '').toLowerCase()))
+    .filter((t) => !isInternalNextMoveTask(t))
     .map((t) => ({
       title: String(t.title).trim(),
       why: `task in flight (${t.status}${t.claimed_by ? `, ${t.claimed_by}` : ''})`,
       source: 'task',
+      task_id: t.id || null,
       ref: t.display_id || t.id || null,
       weight: WEIGHT.task,
     }));
 }
 
+function isInternalNextMoveTask(task) {
+  const title = String(task?.title || '').trim();
+  const tags = [task?.tag, ...(Array.isArray(task?.tags) ? task.tags : [])]
+    .filter(Boolean)
+    .map((tag) => String(tag).toLowerCase());
+  return tags.includes('agent-xp') || /^mission xp\s*:/i.test(title);
+}
+
+function readHandledTaskTitles(root) {
+  const text = safeRead(path.join(root, '.atris', 'state', 'tasks.projection.json'));
+  if (!text) return [];
+  let proj;
+  try { proj = JSON.parse(text); } catch { return []; }
+  const tasks = Array.isArray(proj && proj.tasks) ? proj.tasks : [];
+  return tasks
+    .filter((t) => t && t.title && ['review', 'done'].includes(String(t.status || '').toLowerCase()))
+    .map((t) => String(t.title).trim())
+    .filter(Boolean);
+}
+
+function readJsonLines(file) {
+  const text = safeRead(file);
+  if (!text) return [];
+  return text.split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => {
+      try { return JSON.parse(line); } catch { return null; }
+    })
+    .filter(Boolean);
+}
+
+function readActiveMissions(root) {
+  const rows = readJsonLines(path.join(root, '.atris', 'state', 'missions.jsonl'));
+  const latest = new Map();
+  for (const row of rows) {
+    if (row && row.id) latest.set(row.id, row);
+  }
+  return Array.from(latest.values())
+    .filter((m) => m && m.objective && !['complete', 'stopped', 'paused'].includes(String(m.status || '').toLowerCase()))
+    .map((m) => ({
+      title: String(m.objective).trim(),
+      why: `active mission (${m.status || 'unknown'}${m.owner ? `, ${m.owner}` : ''})`,
+      source: 'mission',
+      ref: m.id || null,
+      weight: m.status === 'blocked' ? WEIGHT.mission + 5 : WEIGHT.mission,
+    }));
+}
+
+function activeEndgameTaskCount(root) {
+  const text = safeRead(path.join(root, '.atris', 'state', 'tasks.projection.json'));
+  if (!text) return 0;
+  let proj;
+  try { proj = JSON.parse(text); } catch { return 0; }
+  const tasks = Array.isArray(proj && proj.tasks) ? proj.tasks : [];
+  return tasks.filter((t) => {
+    if (!t) return false;
+    const status = String(t.status || '').toLowerCase();
+    const tags = [t.tag, ...(Array.isArray(t.tags) ? t.tags : [])].filter(Boolean).map((tag) => String(tag).toLowerCase());
+    return tags.includes('endgame') && ['open', 'claimed', 'review'].includes(status);
+  }).length;
+}
+
+function todoKeepsEndgameActive(root) {
+  const text = safeRead(path.join(root, 'atris', 'TODO.md'));
+  if (!text) return true;
+  if (activeEndgameTaskCount(root) > 0) return true;
+
+  let sawEndgameHeader = false;
+  let section = '';
+  for (const raw of text.split(/\r?\n/)) {
+    const heading = raw.match(/^##\s+(.+?)\s*$/);
+    if (heading) {
+      section = heading[1].trim().toLowerCase();
+      if (section === 'endgame') sawEndgameHeader = true;
+      continue;
+    }
+    if (!/\[endgame\]/i.test(raw)) continue;
+    if (['backlog', 'in progress', 'review'].includes(section)) return true;
+  }
+  return !sawEndgameHeader;
+}
+
+function readEndgameMove(root) {
+  if (!todoKeepsEndgameActive(root)) return [];
+  let state = null;
+  try { state = JSON.parse(safeRead(path.join(root, 'atris', 'brain', 'state.json'))); } catch { state = null; }
+  const horizon = String(state?.endgame?.horizon || '').trim();
+  if (!horizon) return [];
+  return [{
+    title: horizon,
+    why: state?.endgame?.source ? `endgame: ${state.endgame.source}` : 'endgame horizon from compiled brain',
+    source: 'endgame',
+    weight: WEIGHT.endgame,
+  }];
+}
+
 function inboxItemsFrom(text) {
-  return parseInboxTitles(text).map((title) => ({ title, why: 'fresh idea in today\'s inbox', source: 'inbox', weight: WEIGHT.inbox }));
+  return parseInboxTitles(text)
+    .map(cleanInboxMoveTitle)
+    .filter(Boolean)
+    .map((title) => ({ title, why: 'fresh idea in today\'s inbox', source: 'inbox', weight: WEIGHT.inbox }));
 }
 
 // Most recent journal under atris/logs/YYYY/, parsed for ## Inbox items. Used to
@@ -132,6 +256,8 @@ function todayInboxItems(root) {
 function gatherCandidates(root = process.cwd()) {
   return [
     ...readRoadmapOpenItems(root),
+    ...readActiveMissions(root),
+    ...readEndgameMove(root),
     ...readActiveTasks(root),
     ...latestInboxItems(root),
   ];
@@ -144,16 +270,25 @@ function gatherCandidates(root = process.cwd()) {
 // only suppressed for IDEAS (roadmap/inbox), never for a real `task`, so killing
 // or approving an idea can't hide a genuine in-flight task that happens to share
 // the title.
-function pickNextMoves(candidates, { limit = 3, killedIds = [], killedTitles = [], approvedIds = [], approvedTitles = [] } = {}) {
+function pickNextMoves(candidates, {
+  limit = 3,
+  killedIds = [],
+  killedTitles = [],
+  approvedIds = [],
+  approvedTitles = [],
+  handledTaskTitles = [],
+} = {}) {
   const blockedIds = new Set([...killedIds, ...approvedIds]);
-  const blockedTitles = new Set([...killedTitles, ...approvedTitles].map(norm));
+  const blockedTitles = new Set([...killedTitles, ...approvedTitles].map(titleKey));
+  const handledTitles = new Set(handledTaskTitles.map(titleKey));
   const seen = new Set();
   return candidates
-    .map((c) => ({ ...c, id: moveId(c.source, c.title), _key: norm(c.title) }))
+    .map((c) => ({ ...c, id: moveId(c.source, c.title), _key: titleKey(c.title) }))
     .filter((c) => {
       if (!c._key) return false;
       if (blockedIds.has(c.id)) return false;
       if (c.source !== 'task' && blockedTitles.has(c._key)) return false;
+      if (c.source !== 'task' && handledTitles.has(c._key)) return false;
       return true;
     })
     .sort((a, b) => (b.weight || 0) - (a.weight || 0))
@@ -166,6 +301,63 @@ function pickNextMoves(candidates, { limit = 3, killedIds = [], killedTitles = [
     .slice(0, limit);
 }
 
+function cleanSuggestedTargetTitle(text) {
+  const clean = String(text || '')
+    .replace(/[`*_#>]+/g, '')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .replace(/[.!?:;,]+$/g, '');
+  if (!clean) return '';
+  return clean.charAt(0).toUpperCase() + clean.slice(1);
+}
+
+function suggestedTargetFromReportText(text) {
+  const lines = String(text || '').split(/\r?\n/);
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    const match = lines[index].match(/^\s*Suggested target:\s*(.+?)\s*$/i);
+    if (match) return cleanSuggestedTargetTitle(match[1]);
+  }
+  return '';
+}
+
+function latestSuggestedTarget(root = process.cwd()) {
+  const reportsDir = path.join(root, 'atris', 'reports');
+  let files;
+  try {
+    files = fs.readdirSync(reportsDir).filter((file) => /\.md$/i.test(file)).sort().reverse();
+  } catch {
+    return '';
+  }
+  for (const file of files) {
+    const target = suggestedTargetFromReportText(safeRead(path.join(reportsDir, file)));
+    if (target) return target;
+  }
+  return '';
+}
+
+function addMissionOnlyFallback(moves, limit = 3, root = process.cwd()) {
+  if (!Array.isArray(moves) || moves.length !== 1 || limit <= 1) return moves;
+  const mission = moves[0];
+  if (!mission || mission.source !== 'mission') return moves;
+  const suggested = latestSuggestedTarget(root);
+  const target = suggested && !isGenericInboxPlaceholder(suggested)
+    ? suggested
+    : SELF_IMPROVEMENT_SEED_TITLE;
+  return [
+    mission,
+    {
+      title: target,
+      why: target === SELF_IMPROVEMENT_SEED_TITLE
+        ? 'active mission has no concrete task queued'
+        : 'latest proof timeline suggested this self-improvement target',
+      source: 'mission',
+      ref: mission.ref || null,
+      weight: WEIGHT.mission - 35,
+      id: moveId('mission', target),
+    },
+  ].slice(0, limit);
+}
+
 const DECISIONS_FILE = ['.atris', 'state', 'moves.decisions.jsonl'];
 
 function decisionsPath(root) {
@@ -336,20 +528,34 @@ function pickRoadmapSeed(root = process.cwd()) {
 // so the ranking inputs live in one place.
 function nextMoves(root = process.cwd(), limit = 3) {
   const { killedIds, killedTitles, approvedIds, approvedTitles } = readDecisions(root);
-  return pickNextMoves(gatherCandidates(root), { limit, killedIds, killedTitles, approvedIds, approvedTitles });
+  const handledTaskTitles = readHandledTaskTitles(root);
+  const picked = pickNextMoves(gatherCandidates(root), { limit, killedIds, killedTitles, approvedIds, approvedTitles, handledTaskTitles });
+  return addMissionOnlyFallback(picked, limit, root);
 }
 
 module.exports = {
   moveId,
   norm,
+  titleKey,
+  isGenericInboxPlaceholder,
   WEIGHT,
+  SELF_IMPROVEMENT_SEED_TITLE,
+  cleanSuggestedTargetTitle,
+  suggestedTargetFromReportText,
+  latestSuggestedTarget,
   parseInboxTitles,
+  cleanInboxMoveTitle,
   readRoadmapOpenItems,
+  readActiveMissions,
+  readEndgameMove,
   readActiveTasks,
+  isInternalNextMoveTask,
+  readHandledTaskTitles,
   latestInboxItems,
   todayInboxItems,
   gatherCandidates,
   pickNextMoves,
+  addMissionOnlyFallback,
   nextMoves,
   readDecisions,
   recordDecision,

package/lib/operator-next.js

@@ -0,0 +1,7 @@
+function printOperatorNext(command, { label = 'Next' } = {}) {
+  const clean = String(command || '').trim();
+  if (!clean) return;
+  console.log(`${label}: ${clean}`);
+}
+
+module.exports = { printOperatorNext };

package/lib/pulse.js

@@ -14,6 +14,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const { DEFAULT_CLAUDE_RUNNER_MODEL } = require('./runner-command');
 
 const PULSE_RECEIPT_SCHEMA = 'atris.pulse_tick.v1';
 // Reuse the improve-tick scorecard schema so the brain + policy-lessons see
@@ -85,6 +86,21 @@ function buildPulseScorecardRow(input = {}) {
   };
 }
 
+function buildInterruptedPulseReceipt(input = {}) {
+  const signal = input.signal || 'signal';
+  return buildPulseReceipt({
+    tickIndex: input.tickIndex,
+    phase: 'finished',
+    actor: 'pulse_signal',
+    actorOk: false,
+    actorReason: String(signal).toLowerCase(),
+    what: `tick interrupted by ${signal}`,
+    elapsedMs: input.startedAt ? Date.now() - input.startedAt : input.elapsedMs,
+    prevTickStale: input.prevTickStale,
+    reward: -1,
+  });
+}
+
 // The heartbeat's full composition (mirrors the /loop skill): run the due
 // mission to continue an existing goal; if none is due, fall back to an
 // autopilot tick — that path is where proposeCandidateHorizons AUTHORS a new
@@ -198,6 +214,61 @@ function shellSingleQuote(value) {
   return `'${String(value || '').replace(/'/g, "'\\''")}'`;
 }
 
+function normalizeCronCadence(value = DEFAULT_CADENCE_CRON) {
+  const raw = String(value || DEFAULT_CADENCE_CRON).trim();
+  if (!raw) return DEFAULT_CADENCE_CRON;
+  if (raw.toLowerCase() === 'hourly') return DEFAULT_CADENCE_CRON;
+  if (raw.toLowerCase() === 'daily') return '23 2 * * *';
+  if (raw.split(/\s+/).length === 5) return raw;
+
+  const minutes = raw.match(/^(\d+)\s*(m|min|mins|minute|minutes)$/i);
+  if (minutes) {
+    const n = Number(minutes[1]);
+    if (Number.isInteger(n) && n >= 1 && n <= 59) return `*/${n} * * * *`;
+    throw new Error(`invalid cadence "${raw}": minute cadence must be 1m-59m or a 5-field cron`);
+  }
+
+  const hours = raw.match(/^(\d+)\s*(h|hr|hrs|hour|hours)$/i);
+  if (hours) {
+    const n = Number(hours[1]);
+    if (Number.isInteger(n) && n >= 1 && n <= 23) return `23 */${n} * * *`;
+    if (n === 24) return '23 0 * * *';
+    throw new Error(`invalid cadence "${raw}": hour cadence must be 1h-24h or a 5-field cron`);
+  }
+
+  throw new Error(`invalid cadence "${raw}": use 13m, 2h, hourly, daily, or a 5-field cron`);
+}
+
+function normalizeExpiryDuration(input = {}) {
+  const hasHours = input.hours !== undefined && input.hours !== null && String(input.hours).trim() !== '';
+  if (hasHours) {
+    const hours = Number(input.hours);
+    if (Number.isFinite(hours) && hours > 0) {
+      return {
+        source: 'hours',
+        hours,
+        days: null,
+        seconds: Math.ceil(hours * 60 * 60),
+      };
+    }
+    throw new Error(`invalid hours "${input.hours}": use a positive number of hours`);
+  }
+
+  const rawDays = input.days === undefined || input.days === null || String(input.days).trim() === ''
+    ? 7
+    : input.days;
+  const days = Number(rawDays);
+  if (Number.isFinite(days) && days > 0) {
+    return {
+      source: 'days',
+      hours: null,
+      days,
+      seconds: Math.ceil(days * 24 * 60 * 60),
+    };
+  }
+  throw new Error(`invalid days "${rawDays}": use a positive number of days`);
+}
+
 function runnerEnvAliasExport({ genericName, legacyName, value }) {
   if (!value) return '';
   return [
@@ -284,7 +355,7 @@ function buildTickScript(opts = {}) {
     stateHome,
     deadlineEpoch,
     marker = PULSE_MARKER,
-    model = 'opus',
+    model = DEFAULT_CLAUDE_RUNNER_MODEL,
     runnerProfile = '',
     runnerBin = '',
     runnerCommandTemplate = '',
@@ -349,8 +420,8 @@ log="$LOG_DIR/$stamp.log"
 
 cd "$ROOT" || { echo "$(date -Iseconds) ROOT missing" >> "$LOG_DIR/control.log"; exit 1; }
 
-# Autonomous ticks must target a live model alias, never a versioned id that can
-# retire out from under the loop (lesson: retired-model-kills-loop-silently).
+# Autonomous ticks use the pinned default unless the installer supplied a model.
+# Operators can still override per install with --model or env.
 ${runnerModelExport}
 ${runnerProfileExport}
 ${runnerBinExport}
@@ -365,7 +436,7 @@ echo "done: $(date -Iseconds) exit=$?" >> "$log"
 function buildCrontabLine(opts = {}) {
   const { cron = DEFAULT_CADENCE_CRON, scriptPath, marker = PULSE_MARKER } = opts;
   if (!scriptPath) throw new Error('buildCrontabLine: scriptPath is required');
-  return `${cron} ${scriptPath} # ${marker}`;
+  return `${normalizeCronCadence(cron)} ${scriptPath} # ${marker}`;
 }
 
 module.exports = {
@@ -382,7 +453,9 @@ module.exports = {
   pulseLockDir,
   buildPulseReceipt,
   buildPulseScorecardRow,
+  buildInterruptedPulseReceipt,
   scoreTick,
+  normalizeExpiryDuration,
   shouldWriteScorecard,
   shouldFallbackToAutopilot,
   findOrphanStarts,
@@ -398,4 +471,5 @@ module.exports = {
   releaseLock,
   buildTickScript,
   buildCrontabLine,
+  normalizeCronCadence,
 };

package/lib/runner-command.js

@@ -3,33 +3,47 @@
 // Shared worker-spawn builder for the autonomous loops (missions, autopilot, run).
 //
 // Autonomous ticks must target a LIVE model. Inheriting the CLI's persisted
-// selection is fragile: a *versioned* id (e.g. claude-fable-5) silently dies
-// when that version is retired, and every tick then errors as a generic
-// 'claude-error' with no clue why (lesson: retired-model-kills-loop-silently,
-// CLI-245). Precedence: explicit model -> ATRIS_RUNNER_MODEL env ->
-// ATRIS_RUNNER_PROFILE -> legacy ATRIS_CLAUDE_MODEL env -> 'opus' alias. The
-// CLI resolves aliases to the latest live model, so an alias never retires out
-// from under the loop.
-const DEFAULT_CLAUDE_RUNNER_MODEL = 'opus';
+// selection is fragile: the local Claude Code `opus` alias can resolve to
+// different Opus releases across machines and account rollouts. Pin the default
+// so autonomous runs are reproducible, while keeping explicit per-run/env knobs
+// first in precedence. Precedence: explicit model -> ATRIS_RUNNER_MODEL env ->
+// ATRIS_RUNNER_PROFILE -> legacy ATRIS_CLAUDE_MODEL env -> pinned default.
+const DEFAULT_CLAUDE_RUNNER_MODEL = 'claude-opus-4-8';
 const DEFAULT_CLAUDE_RUNNER_BIN = 'claude';
-const RUNNER_PROFILES = Object.freeze({
+
+// Canonical runner profiles. Each entry is the config an operator would pick
+// on purpose. Aliases (spelling variants of the same profile) resolve to the
+// canonical config but are kept OUT of operator-facing lists so config errors
+// stay honest: "one of: atris-fast", not three duplicate spellings.
+const RUNNER_PROFILE_DEFS = Object.freeze({
   'atris-fast': Object.freeze({
     bin: 'ax',
     model: 'atris:fast',
     commandTemplate: '{bin} --fast {prompt}',
   }),
-  'atris2-fast': Object.freeze({
-    bin: 'ax',
-    model: 'atris:fast',
-    commandTemplate: '{bin} --fast {prompt}',
-  }),
-  'atris-2-fast': Object.freeze({
-    bin: 'ax',
-    model: 'atris:fast',
-    commandTemplate: '{bin} --fast {prompt}',
-  }),
 });
 
+// Alias -> canonical profile name. Every alias resolves to the same config as
+// its canonical target; adding a spelling variant here is a config change, not
+// a duplicated profile body that can drift.
+const RUNNER_PROFILE_ALIASES = Object.freeze({
+  'atris2-fast': 'atris-fast',
+  'atris-2-fast': 'atris-fast',
+});
+
+// Back-compat surface: RUNNER_PROFILES still resolves every accepted name
+// (canonical + alias) to its frozen config, so existing lookups by any spelling
+// keep working.
+const RUNNER_PROFILES = Object.freeze(
+  Object.fromEntries([
+    ...Object.entries(RUNNER_PROFILE_DEFS),
+    ...Object.entries(RUNNER_PROFILE_ALIASES).map(([alias, target]) => [alias, RUNNER_PROFILE_DEFS[target]]),
+  ])
+);
+
+// Operator-facing list: canonical profile names only (no alias noise).
+const RUNNER_PROFILE_NAMES = Object.freeze(Object.keys(RUNNER_PROFILE_DEFS));
+
 function shellWord(value) {
   const s = String(value || '');
   if (/^[A-Za-z0-9_./:-]+$/.test(s)) return s;
@@ -53,7 +67,7 @@ function resolveRunnerProfile() {
   if (!name) return null;
   const profile = RUNNER_PROFILES[name];
   if (!profile) {
-    throw new Error(`Unknown ATRIS_RUNNER_PROFILE "${name}". Known profiles: ${Object.keys(RUNNER_PROFILES).join(', ')}`);
+    throw new Error(`Unknown ATRIS_RUNNER_PROFILE "${name}". Known profiles: ${RUNNER_PROFILE_NAMES.join(', ')}`);
   }
   return profile;
 }
@@ -97,6 +111,19 @@ function buildRunnerAvailabilityCommand() {
   return `command -v ${shellWord(resolveClaudeRunnerBin())}`;
 }
 
+function runnerAvailabilityFailureMessage(error) {
+  const message = error && error.message ? String(error.message).trim() : '';
+  if (message.startsWith('Unknown ATRIS_RUNNER_PROFILE')) {
+    return `${message}. Set ATRIS_RUNNER_PROFILE to one of: ${RUNNER_PROFILE_NAMES.join(', ')}.`;
+  }
+
+  let runnerBin = 'configured runner';
+  try {
+    runnerBin = resolveClaudeRunnerBin();
+  } catch {}
+  return `${runnerBin} CLI not found. Set ATRIS_RUNNER_BIN (or legacy ATRIS_CLAUDE_BIN), or install the configured runner first.`;
+}
+
 function renderRunnerCommandTemplate(template, { promptFile, allowedTools, model }) {
   const allowedToolsFlag = allowedTools ? `--allowedTools ${shellWord(allowedTools)}` : '';
   const promptFileWord = shellWord(promptFile);
@@ -143,6 +170,9 @@ module.exports = {
   DEFAULT_CLAUDE_RUNNER_MODEL,
   DEFAULT_CLAUDE_RUNNER_BIN,
   RUNNER_PROFILES,
+  RUNNER_PROFILE_DEFS,
+  RUNNER_PROFILE_ALIASES,
+  RUNNER_PROFILE_NAMES,
   resolveRunnerProfileName,
   resolveRunnerProfile,
   resolveRunnerModel: resolveClaudeRunnerModel,
@@ -152,5 +182,6 @@ module.exports = {
   resolveClaudeRunnerBin,
   resolveClaudeRunnerCommandTemplate,
   buildRunnerAvailabilityCommand,
+  runnerAvailabilityFailureMessage,
   buildRunnerCommand,
 };