atris 3.34.0 → 3.36.0

package/lib/member-switches.js

@@ -0,0 +1,144 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const SWITCHES_REL = path.join('.atris', 'state', 'member-switches.json');
+
+function switchesPath(root = process.cwd()) {
+  return path.join(root, SWITCHES_REL);
+}
+
+function emptyState() {
+  return { members: {} };
+}
+
+function loadMemberSwitches(root = process.cwd()) {
+  const file = switchesPath(root);
+  try {
+    const raw = JSON.parse(fs.readFileSync(file, 'utf8'));
+    if (!raw || typeof raw !== 'object') return emptyState();
+    if (!raw.members || typeof raw.members !== 'object') return emptyState();
+    return { members: raw.members };
+  } catch {
+    return emptyState();
+  }
+}
+
+function writeAtomicJson(file, value) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  fs.writeFileSync(tmp, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+  fs.renameSync(tmp, file);
+}
+
+function saveMemberSwitches(state, root = process.cwd()) {
+  const next = state && typeof state === 'object' ? state : emptyState();
+  if (!next.members || typeof next.members !== 'object') next.members = {};
+  writeAtomicJson(switchesPath(root), next);
+  return next;
+}
+
+function isLocalMember(name, root = process.cwd()) {
+  const slug = String(name || '').trim();
+  if (!slug || slug.startsWith('-')) return false;
+  if (!/^[a-zA-Z0-9._-]+$/.test(slug)) return false;
+  return fs.existsSync(path.join(root, 'atris', 'team', slug, 'MEMBER.md'));
+}
+
+function normalizeMemberEntry(entry) {
+  const base = entry && typeof entry === 'object' ? entry : {};
+  const loops = base.loops && typeof base.loops === 'object' ? { ...base.loops } : {};
+  return {
+    awake: base.awake !== false,
+    loops,
+  };
+}
+
+function getMemberSwitch(name, root = process.cwd()) {
+  const state = loadMemberSwitches(root);
+  return normalizeMemberEntry(state.members[name]);
+}
+
+function isMemberAwake(name, root = process.cwd()) {
+  return getMemberSwitch(name, root).awake !== false;
+}
+
+function isMemberLoopAwake(name, loopId, root = process.cwd()) {
+  const entry = getMemberSwitch(name, root);
+  if (entry.awake === false) return false;
+  const id = String(loopId || '').trim();
+  if (!id) return entry.awake !== false;
+  if (Object.prototype.hasOwnProperty.call(entry.loops, id)) {
+    return entry.loops[id] !== false;
+  }
+  return true;
+}
+
+function ensureMemberEntry(state, name) {
+  if (!state.members[name] || typeof state.members[name] !== 'object') {
+    state.members[name] = { awake: true, loops: {} };
+  }
+  if (!state.members[name].loops || typeof state.members[name].loops !== 'object') {
+    state.members[name].loops = {};
+  }
+  if (typeof state.members[name].awake !== 'boolean') {
+    state.members[name].awake = state.members[name].awake !== false;
+  }
+  return state.members[name];
+}
+
+function setMemberAwake(name, awake, root = process.cwd()) {
+  const state = loadMemberSwitches(root);
+  const entry = ensureMemberEntry(state, name);
+  entry.awake = awake !== false;
+  saveMemberSwitches(state, root);
+  return normalizeMemberEntry(entry);
+}
+
+function setMemberLoopAwake(name, loopId, awake, root = process.cwd()) {
+  const id = String(loopId || '').trim();
+  if (!id) throw new Error('loop id required');
+  const state = loadMemberSwitches(root);
+  const entry = ensureMemberEntry(state, name);
+  entry.loops[id] = awake !== false;
+  saveMemberSwitches(state, root);
+  return normalizeMemberEntry(entry);
+}
+
+function readLoopFlag(argv = process.argv) {
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === '--loop') {
+      const value = argv[i + 1];
+      if (value && !String(value).startsWith('-')) return String(value).trim();
+      return '';
+    }
+    if (String(arg).startsWith('--loop=')) {
+      return String(arg).slice('--loop='.length).trim();
+    }
+  }
+  return '';
+}
+
+function memberArgFromArgv(argv = process.argv) {
+  // atris sleep|wake <name> [--loop <id>]
+  const raw = argv[3];
+  if (!raw || String(raw).startsWith('-')) return null;
+  return String(raw).trim();
+}
+
+module.exports = {
+  SWITCHES_REL,
+  switchesPath,
+  loadMemberSwitches,
+  saveMemberSwitches,
+  isLocalMember,
+  getMemberSwitch,
+  isMemberAwake,
+  isMemberLoopAwake,
+  setMemberAwake,
+  setMemberLoopAwake,
+  readLoopFlag,
+  memberArgFromArgv,
+};

package/lib/memory-view.js

@@ -9,13 +9,18 @@
 const fs = require('fs');
 const path = require('path');
 
-// "- **[2026-06-18] some-id** — pass — text..." -> { date, id, status, text }
+// "- **[2026-06-18] some-id** — pass — text..." -> { date, id, status, text, resolved }
+// A leading "[resolved]" marker (written when a lesson's detector passes) is
+// stripped from the text and surfaced as `resolved` so the view can retire it.
 function parseLessons(text) {
   const out = [];
   for (const line of String(text || '').split('\n')) {
     const m = line.match(/^-\s*\*\*\[([^\]]+)\]\s*([^*]+?)\*\*\s*[—:-]*\s*(pass|fail)?\s*[—:-]*\s*(.*)$/i);
     if (!m) continue;
-    out.push({ date: m[1].trim(), id: m[2].trim(), status: (m[3] || '').toLowerCase(), text: m[4].trim() });
+    let body = m[4].trim();
+    const resolved = /\[resolved\]/i.test(body);
+    body = body.replace(/\[resolved\]\s*/i, '').trim();
+    out.push({ date: m[1].trim(), id: m[2].trim(), status: (m[3] || '').toLowerCase(), text: body, resolved });
   }
   return out; // append-only file: oldest first
 }
@@ -55,15 +60,18 @@ function buildMemorySpec(root = process.cwd(), opts = {}) {
   const theme = opts.theme || 'atris';
   const brand = { name: opts.brand || 'Atris', accent: '.' };
   const { lessons, learnings, tasks } = gatherMemory(root);
+  const openLessons = lessons.filter((l) => !l.resolved);
+  const resolvedCount = lessons.length - openLessons.length;
   const recent = lessons.slice(-8).reverse(); // newest first
 
+  const retired = resolvedCount ? `, ${plural(resolvedCount, 'lesson')} auto-resolved` : '';
   const slides = [];
   slides.push({
     type: 'title',
     headline: 'What the workspace **learned**',
-    sub: `${plural(lessons.length, 'lesson')} and ${plural(learnings.length, 'note')} compounded into memory${tasks ? `, ${plural(tasks.done, 'task')} done` : ''}.`,
+    sub: `${plural(openLessons.length, 'open lesson')}${retired} and ${plural(learnings.length, 'note')} compounded into memory${tasks ? `, ${plural(tasks.done, 'task')} done` : ''}.`,
   });
-  slides.push({ type: 'bignumber', number: String(lessons.length), label: 'lessons compounded into the workspace' });
+  slides.push({ type: 'bignumber', number: String(openLessons.length), label: `open lessons${resolvedCount ? ` (${resolvedCount} retired)` : ''}` });
 
   if (recent.length) {
     slides.push({
@@ -76,7 +84,8 @@ function buildMemorySpec(root = process.cwd(), opts = {}) {
         header: { title: 'Recent updates', meta: `${recent.length} shown` },
         rows: recent.map((l, i) => ({
           title: titleize(l.id), sub: l.date,
-          value: l.status || 'note', sev: l.status === 'fail' ? 0 : (l.status === 'pass' ? 2 : 1),
+          value: l.resolved ? 'resolved' : (l.status || 'note'),
+          sev: l.resolved ? 2 : (l.status === 'fail' ? 0 : (l.status === 'pass' ? 2 : 1)),
           active: i === 0,
         })),
       },

package/lib/mission-room.js

@@ -799,6 +799,7 @@ function writeMissionRoomReceipt(room, options = {}) {
     schema: 'atris.mission_room_receipt.v1',
     at: at.toISOString(),
     product_wedge: 'Chaos -> Mission Room',
+    ...(roomWithMemory.wish_id ? { wish_id: roomWithMemory.wish_id } : {}),
     room: roomWithMemory,
     thinking_memory: thinkingMemory,
     receipt_path: relativePath,

package/lib/mission-root.js

@@ -0,0 +1,52 @@
+'use strict';
+
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+// The mission store lives at <workspace>/.atris/state. Historically every
+// mission entry point defaulted its root to process.cwd(), so running any
+// `atris mission ...` verb from a subdirectory (e.g. atris/features/food-ordering)
+// silently created a NESTED .atris there — a second, split-brain mission store
+// the fleet never reads. Resolve to the workspace root so mission state always
+// lands there, whichever subdir the caller happened to be in.
+//
+// This delegates to the SAME resolver the task/usage/goal store uses
+// (lib/task-db findWorkspaceRoot): a bound customer sub-workspace spine
+// (.atris/business.json | atris/atris.md) wins, else the git toplevel, else the
+// caller's cwd. Sharing one resolver keeps mission state and task state in the
+// same root — previously mission used only the git toplevel, so a mission
+// started inside a bound sub-workspace split away from that workspace's task
+// state. A git worktree reports its own toplevel (its .git marker), which is
+// the correct per-worktree store, so --worktree missions are unaffected. If the
+// shared resolver can't load, fall back to the git toplevel, then to cwd.
+function resolveWorkspaceRoot(cwd = process.cwd()) {
+  try {
+    const { workspaceRoot } = require('./task-db');
+    const root = workspaceRoot(cwd);
+    if (root) return root;
+  } catch {}
+  try {
+    const top = spawnSync('git', ['rev-parse', '--show-toplevel'], { cwd, encoding: 'utf8' });
+    const root = String(top.stdout || '').trim();
+    if (top.status === 0 && root) return root;
+  } catch {}
+  return cwd;
+}
+
+// Chdir to the workspace root before any mission state is written, so a caller
+// standing in a subdirectory does not spawn a nested .atris store. Only
+// redirects when cwd is strictly INSIDE the resolved root (a subdirectory);
+// if cwd already IS the root, or somehow sits outside it, nothing moves.
+// Returns { from, root } when it redirected so the caller can warn loudly,
+// or null when it left cwd untouched.
+function redirectToWorkspaceRoot(cwd = process.cwd()) {
+  const from = path.resolve(cwd);
+  const root = path.resolve(resolveWorkspaceRoot(from));
+  if (root === from) return null;
+  const rel = path.relative(root, from);
+  if (!rel || rel.startsWith('..') || path.isAbsolute(rel)) return null;
+  process.chdir(root);
+  return { from, root };
+}
+
+module.exports = { resolveWorkspaceRoot, redirectToWorkspaceRoot };

package/lib/mission-runtime-loop.js

@@ -57,7 +57,10 @@ function missionRunIntentFromMessage(message) {
   rest = cadenceFlag.text;
   const noRun = hasBooleanFlag(rest, '--no-run') || hasBooleanFlag(rest, '--no-loop');
   const noComplete = hasBooleanFlag(rest, '--no-complete');
+  const forceRoomPreflight = hasBooleanFlag(rest, '--preflight') || hasBooleanFlag(rest, '--room-preflight');
+  const skipRoomPreflight = hasBooleanFlag(rest, '--no-preflight') || hasBooleanFlag(rest, '--no-room-preflight') || !forceRoomPreflight;
   rest = stripBooleanFlag(stripBooleanFlag(stripBooleanFlag(rest, '--no-run'), '--no-loop'), '--no-complete');
+  rest = stripBooleanFlag(stripBooleanFlag(stripBooleanFlag(stripBooleanFlag(rest, '--preflight'), '--room-preflight'), '--no-preflight'), '--no-room-preflight');
   rest = rest.replace(/(^|\s)--json(?=\s|$)/g, ' ').replace(/\s+/g, ' ').trim();
 
   const wantsLongRun = /\b(24\s*h|24\s*hours?|overnight|forever)\b/i.test(text);
@@ -69,6 +72,8 @@ function missionRunIntentFromMessage(message) {
     cadence: cadenceFlag.value || (wantsLongRun ? '15m' : ''),
     noRun,
     noComplete,
+    roomPreflight: forceRoomPreflight,
+    noRoomPreflight: skipRoomPreflight,
   };
 }
 
@@ -245,6 +250,8 @@ async function runRuntimeMissionLoop(intent, options = {}) {
 
   const startArgs = ['mission', 'run', intent.objective, '--runner', 'atris2', '--owner', intent.owner || 'mission-lead', '--json'];
   if (intent.cadence) startArgs.push('--cadence', intent.cadence);
+  if (intent.roomPreflight) startArgs.push('--room-preflight');
+  else if (intent.noRoomPreflight) startArgs.push('--no-room-preflight');
   const start = runCliJsonSync(cliPath, startArgs, { cwd, timeoutMs: 30000 });
   const result = { ok: start.ok, status: start.status, start, noRun: intent.noRun === true, achieved: false };
   if (!start.ok || !start.payload?.mission?.id) {