atris 3.42.0 → 3.44.0

package/lib/known-commands.js

@@ -1,9 +1,9 @@
 'use strict';
 
-const knownCommands = ['init', 'log', 'logs', 'wish', 'drill', 'dream', 'now', 'goal', 'wtf', 'orb', 'radar', 'stream', 'ctop', 'launchpad', 'status', 'analytics', 'visualize', 'brain', 'brainstorm', 'autopilot', 'run', '_start', 'plan', 'do', 'review', 'release',
+const knownCommands = ['init', 'log', 'logs', 'wish', 'ask', 'approve', 'stop', 'ready', 'check', 'drill', 'dream', 'now', 'goal', 'wtf', 'founder', 'orb', 'radar', 'stream', 'ctop', 'launchpad', 'status', 'analytics', 'visualize', 'brain', 'brainstorm', 'autopilot', 'run', '_start', 'plan', 'do', 'review', 'release',
                        'activate', '_activate', 'agent', 'team', 'chat', 'fast', 'ax', 'console', 'serve', 'login', 'logout', 'whoami', 'switch', 'use', 'accounts', '_resolve', '_profile-email', '_switch-session', 'shell-init', 'update', 'upgrade', 'version', 'help', 'next', 'atris',
                        'clean', 'close', 'harvest', 'verify', 'recover', 'search', 'scout', 'skill', 'member', 'codex-goal', 'app', 'apps', 'learn', 'lesson', 'taste', 'teach', 'plugin', 'experiments', 'bench', 'router', 'receipt', 'proof', 'openclaw', 'pull', 'push', 'watch', 'cloud', 'live', 'align', 'terminal', 'computer', 'diff', 'business', 'sync', 'youtube',
-                       'ingest', 'query', 'lint', 'loop', 'pulse', 'task', 'mission', 'decide', 'agents', 'probe', 'worktree', 'land', 'autoland', 'drive', 'aeo', 'slop', 'voice', 'strings', 'write', 'security-review', 'secure', 'deck', 'site', 'theme', 'card', 'reel', 'improve', 'study', 'rainmaker', 'xp', 'play', 'gm', 'game', 'x', 'recap', 'report', 'signup', 'clarity', 'interview', 'meet', 'moves', 'unknowns', 'avail', 'sync-checkout',
+                       'ingest', 'query', 'lint', 'loop', 'pulse', 'task', 'mission', 'decide', 'agents', 'probe', 'worktree', 'land', 'caretaker', 'autoland', 'drive', 'aeo', 'slop', 'voice', 'strings', 'write', 'security-review', 'secure', 'deck', 'site', 'theme', 'card', 'reel', 'improve', 'study', 'rainmaker', 'xp', 'play', 'gm', 'game', 'x', 'recap', 'report', 'signup', 'clarity', 'interview', 'meet', 'moves', 'unknowns', 'avail', 'sync-checkout',
                        'github', 'vercel', 'supabase', 'linear', 'stripe', 'gmail', 'calendar', 'twitter', 'slack', 'imessage', 'integrations', 'setup', 'clean-workspace', 'cw',
                        'fork', 'browse', 'publish', 'pack', 'sleep', 'wake', 'feedback', 'errors', 'wiki', 'code-review', 'cr', 'soul', 'fleet', 'fleet-report', 'loops', 'self-improve', 'compile', 'spaceship', 'truth', 'sign', 'engine', 'engines', 'feed', 'brief'];
 

package/lib/lesson-ledger.js

@@ -0,0 +1,84 @@
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { spawnSync } = require('child_process');
+
+/**
+ * Lesson contract validation + append-only mutation ledger.
+ *
+ * Every lesson mutation (add / resolve / revert) lands one JSONL record in
+ * .atris/state/lesson_ledger.jsonl with evidence and an id, so self-improvement
+ * edits are auditable and reversible instead of silent sidecar rewrites. The
+ * ledger is append-only: revert writes a new record, it never deletes history.
+ */
+
+const LEDGER_REL = path.join('.atris', 'state', 'lesson_ledger.jsonl');
+
+function ledgerPath(root) {
+  return path.join(root, LEDGER_REL);
+}
+
+/**
+ * Validate a detector command at write time. A detector is a shell command
+ * whose exit code is the lesson's falsifiable state (0 = bug gone). At add
+ * time either exit code is fine (the bug usually still exists) but the
+ * command itself must run: empty strings, missing binaries (127), and
+ * non-executable targets (126) are rejected so a typo can't masquerade as a
+ * forever-failing detector.
+ * @returns {{ ok: boolean, exitCode?: number, reason?: string }}
+ */
+function validateDetector(cmd, cwd, timeoutMs = 10000) {
+  if (!cmd || typeof cmd !== 'string' || !cmd.trim()) {
+    return { ok: false, reason: 'detector is empty' };
+  }
+  const res = spawnSync(cmd, { shell: true, cwd, timeout: timeoutMs, stdio: 'pipe' });
+  if (res.error) return { ok: false, reason: res.error.message };
+  if (res.signal) return { ok: false, reason: `detector killed by ${res.signal} (timeout?)` };
+  if (res.status === 127) return { ok: false, exitCode: 127, reason: 'command not found (exit 127)' };
+  if (res.status === 126) return { ok: false, exitCode: 126, reason: 'command not executable (exit 126)' };
+  return { ok: true, exitCode: res.status };
+}
+
+/**
+ * Append one mutation record. Adds id + ts; returns the full record.
+ * @param {string} root
+ * @param {{ action: 'add'|'resolve'|'revert', slug: string, evidence?: string, outcome?: string }} entry
+ */
+function appendLedgerEntry(root, entry) {
+  const file = ledgerPath(root);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const record = {
+    id: `ll-${Date.now().toString(36)}-${crypto.randomBytes(3).toString('hex')}`,
+    ts: new Date().toISOString(),
+    ...entry,
+  };
+  fs.appendFileSync(file, JSON.stringify(record) + '\n');
+  return record;
+}
+
+/**
+ * Read ledger records, oldest first. Malformed lines are skipped, not fatal:
+ * a half-written line from a crashed process must not brick the view.
+ * @param {string} root
+ * @param {{ limit?: number, slug?: string }} [options]
+ */
+function readLedger(root, options = {}) {
+  const file = ledgerPath(root);
+  if (!fs.existsSync(file)) return [];
+  const records = [];
+  for (const line of fs.readFileSync(file, 'utf8').split('\n')) {
+    if (!line.trim()) continue;
+    try {
+      records.push(JSON.parse(line));
+    } catch {
+      // skip torn line
+    }
+  }
+  const filtered = options.slug ? records.filter((r) => r.slug === options.slug) : records;
+  if (options.limit && filtered.length > options.limit) {
+    return filtered.slice(filtered.length - options.limit);
+  }
+  return filtered;
+}
+
+module.exports = { ledgerPath, validateDetector, appendLedgerEntry, readLedger };

package/lib/member-alive.js

@@ -84,7 +84,7 @@ function runMemberOperateScript(scriptPath, member, opts) {
     args.push('--execute');
     if (opts.confirmed) args.push('--confirm-autonomy-policy');
   }
-  if (opts.agent === 'claude') args.push('--agent', 'claude');
+  if (opts.agent) args.push('--agent', String(opts.agent));
   if (opts.model) args.push('--model', String(opts.model));
   if (opts.noPrime) args.push('--no-prime');
   // Inherit stderr so member-operate progress lines reach the parent alive/loop process live.
@@ -194,7 +194,7 @@ function runAliveTick(name, opts = {}) {
     execute: true,
     confirmed: true,
     maxWallSeconds: opts.maxWallSeconds,
-    agent: opts.agent || 'codex',
+    agent: opts.agent || null,
     model: opts.model || null,
     noPrime: true,
   });

package/lib/policy-lessons.js

@@ -16,6 +16,7 @@ const POLICY_LESSONS_FILE = path.join('.atris', 'state', 'policy_lessons.json');
 const CAREER_XP_RECEIPTS_FILE = path.join('.atris', 'state', 'career_xp_receipts.jsonl');
 const TASK_EPISODES_FILE = path.join('.atris', 'state', 'task_episodes.jsonl');
 const SCORECARDS_FILE = path.join('.atris', 'state', 'scorecards.jsonl');
+const TYPED_LESSONS_FILE = path.join('atris', 'lessons.json');
 const DAY_MS = 24 * 60 * 60 * 1000;
 
 // Review actors that are agents, not the human gate. Mining must split the
@@ -266,6 +267,74 @@ function policyHintsForProof(proofText, mined, root = process.cwd()) {
   return hints;
 }
 
+function normalizeLessonPath(value) {
+  return String(value || '')
+    .trim()
+    .replace(/\\/g, '/')
+    .replace(/^\.\//, '')
+    .replace(/\/{2,}/g, '/')
+    .replace(/\/$/, '');
+}
+
+function lessonPathOverlaps(left, right) {
+  const lessonPath = normalizeLessonPath(left).toLowerCase();
+  const candidatePath = normalizeLessonPath(right).toLowerCase();
+  if (!lessonPath || !candidatePath) return false;
+  return lessonPath === candidatePath
+    || lessonPath.startsWith(`${candidatePath}/`)
+    || candidatePath.startsWith(`${lessonPath}/`);
+}
+
+function readTypedPolicyLessons(root) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(path.join(root, TYPED_LESSONS_FILE), 'utf8'));
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return [];
+    return Object.entries(parsed)
+      .filter(([id, lesson]) => id !== '_schema' && lesson && typeof lesson === 'object')
+      .map(([id, lesson]) => ({ id, ...lesson, source: 'typed_lessons' }));
+  } catch {
+    return [];
+  }
+}
+
+// A lesson is relevant to a landing only when its declared file scope overlaps
+// the candidate's exact paths. Repo-wide or prose-only lessons remain advice,
+// because running them as global blockers would make old debt stop new work.
+function policyLessonsForFiles(files, mined, root = process.cwd()) {
+  const candidatePaths = (Array.isArray(files) ? files : [files])
+    .map(normalizeLessonPath)
+    .filter(Boolean);
+  if (!candidatePaths.length) return [];
+  const minedLessons = mined && Array.isArray(mined.lessons)
+    ? mined.lessons.map((lesson) => ({ ...lesson, source: 'mined_policy' }))
+    : [];
+  // The typed sidecar is the promoted source. If a mined advisory later uses
+  // the same id, the promoted detector and file scope must win.
+  const combined = [...readTypedPolicyLessons(root), ...minedLessons];
+  const matches = [];
+  const seen = new Set();
+  for (const lesson of combined) {
+    const id = String(lesson && lesson.id || '').trim();
+    if (!id || seen.has(id)) continue;
+    const appliesTo = Array.isArray(lesson.applies_to)
+      ? lesson.applies_to
+      : (Array.isArray(lesson.paths) ? lesson.paths : []);
+    const matchedPath = appliesTo.find((lessonPath) =>
+      candidatePaths.some((candidatePath) => lessonPathOverlaps(lessonPath, candidatePath)));
+    if (!matchedPath) continue;
+    seen.add(id);
+    matches.push({
+      id,
+      detector: typeof lesson.detector === 'string' ? lesson.detector.trim() : '',
+      lesson: String(lesson.lesson || lesson.text || '').trim(),
+      status: lesson.status || null,
+      source: lesson.source,
+      matched_path: normalizeLessonPath(matchedPath),
+    });
+  }
+  return matches;
+}
+
 function policyLessonsPath(root) {
   return path.join(root, POLICY_LESSONS_FILE);
 }
@@ -324,6 +393,7 @@ module.exports = {
   loadHistory,
   mineProofPolicy,
   policyHintsForProof,
+  policyLessonsForFiles,
   readPolicyLessons,
   writePolicyLessons,
   syncLessonsMd,

package/lib/receipt-evidence.js

@@ -122,4 +122,59 @@ function extractReceiptEvidence(proofText, root = process.cwd()) {
   };
 }
 
-module.exports = { extractReceiptEvidence, receiptVerifierPassed, RECEIPT_PATH_PATTERN };
+// Resume short-circuit: when a tick already wrote its receipt but the mission
+// record never advanced (interrupt between writeReceipt and saveMission), the
+// next run would re-derive the same tick_index. Look up that completed receipt
+// and reuse it instead of re-running the step.
+function findCachedMissionStepReceipt(root, { missionId, tickIndex } = {}) {
+  const id = String(missionId || '').trim();
+  const idx = Number(tickIndex);
+  if (!id || !Number.isInteger(idx) || idx < 1) return null;
+
+  const runsDir = path.resolve(root, 'atris', 'runs');
+  let names;
+  try {
+    names = fs.readdirSync(runsDir).filter((name) => name.startsWith('mission-') && name.endsWith('.json'));
+  } catch {
+    return null;
+  }
+
+  let best = null;
+  for (const name of names) {
+    let parsed = null;
+    try {
+      parsed = JSON.parse(fs.readFileSync(path.join(runsDir, name), 'utf8'));
+    } catch {
+      continue;
+    }
+    if (!parsed || parsed.mission_id !== id) continue;
+    const tick = parsed.result && parsed.result.tick;
+    if (!tick || Number(tick.tick_index) !== idx) continue;
+    // Only completed successful steps are safe to skip. Failed ticks stay
+    // eligible for a fresh attempt on resume.
+    if (tick.status !== 'ran') continue;
+    const atMs = Date.parse(tick.finished_at || parsed.at || '') || 0;
+    if (best && atMs < best.atMs) continue;
+    best = {
+      atMs,
+      receipt_path: path.join('atris', 'runs', name),
+      receipt: parsed,
+      tick,
+      verifier_result: parsed.result.verifier_result || null,
+    };
+  }
+  if (!best) return null;
+  return {
+    receipt_path: best.receipt_path,
+    receipt: best.receipt,
+    tick: best.tick,
+    verifier_result: best.verifier_result,
+  };
+}
+
+module.exports = {
+  extractReceiptEvidence,
+  receiptVerifierPassed,
+  findCachedMissionStepReceipt,
+  RECEIPT_PATH_PATTERN,
+};

package/lib/runner-command.js

@@ -64,7 +64,7 @@ const RUNNER_PROFILE_DEFS = Object.freeze({
   }),
   grok: Object.freeze({
     bin: 'grok',
-    model: 'grok-4.5',
+    model: 'grok-4.6',
     commandTemplate: '{bin} --always-approve -p {prompt}',
   }),
   droid: Object.freeze({