atris 3.33.3 → 3.35.0

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-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) {

package/lib/official-cli-integration.js

@@ -0,0 +1,174 @@
+const { spawnSync } = require('node:child_process');
+
+function hasHelp(args = []) {
+  return args.includes('--help') || args.includes('-h') || args[0] === 'help';
+}
+
+function firstLine(value) {
+  return String(value || '').split(/\r?\n/).map((line) => line.trim()).find(Boolean) || 'unknown';
+}
+
+function formatCommand(parts = []) {
+  return parts.join(' ').trim();
+}
+
+function runCaptured(binary, args = []) {
+  return spawnSync(binary, args, {
+    encoding: 'utf8',
+    env: process.env,
+  });
+}
+
+function missingBinary(result) {
+  return result && result.error && result.error.code === 'ENOENT';
+}
+
+function printMissingBinary(config) {
+  console.error(`${config.name} cli not found.`);
+  console.error(`install: ${config.installHint}`);
+}
+
+function ensureBinary(config) {
+  const result = runCaptured(config.binary, config.versionArgs || ['--version']);
+  if (missingBinary(result)) {
+    printMissingBinary(config);
+    return { ok: false, result };
+  }
+  if (result.error) {
+    console.error(`${config.name} cli check failed: ${result.error.message}`);
+    return { ok: false, result };
+  }
+  return { ok: true, result };
+}
+
+function runAuthCheck(config) {
+  if (!config.authArgs || config.authArgs.length === 0) {
+    return { ok: true, skipped: true };
+  }
+  const result = runCaptured(config.binary, config.authArgs);
+  if (missingBinary(result)) {
+    printMissingBinary(config);
+    return { ok: false, result };
+  }
+  if (result.error) {
+    console.error(`${config.name} auth check failed: ${result.error.message}`);
+    return { ok: false, result };
+  }
+  return { ok: result.status === 0, result };
+}
+
+function printHelp(config) {
+  console.log('');
+  console.log(`usage: atris ${config.name} <command> [args]`);
+  console.log('');
+  console.log('commands:');
+  console.log('  doctor        detect the cli binary and auth state');
+  console.log('  auth          check auth state');
+  for (const command of config.commands) {
+    console.log(`  ${command.usage.padEnd(13)} ${command.description}`);
+  }
+  console.log('');
+  console.log(`binary: ${config.binary}`);
+  console.log(`install: ${config.installHint}`);
+  console.log('');
+}
+
+function printDoctor(config) {
+  const binary = ensureBinary(config);
+  if (!binary.ok) return 1;
+
+  console.log(`${config.name} integration`);
+  console.log(`binary: found ${config.binary}`);
+  console.log(`version: ${firstLine(binary.result.stdout || binary.result.stderr).toLowerCase()}`);
+
+  const auth = runAuthCheck(config);
+  if (auth.skipped) {
+    console.log('auth: not checked');
+    return 0;
+  }
+  if (auth.ok) {
+    console.log('auth: ok');
+    return 0;
+  }
+  console.error('auth: failed');
+  console.error(`login: ${config.loginHint}`);
+  return 1;
+}
+
+function printAuth(config) {
+  const binary = ensureBinary(config);
+  if (!binary.ok) return 1;
+  const auth = runAuthCheck(config);
+  if (auth.skipped || auth.ok) {
+    console.log('auth: ok');
+    return 0;
+  }
+  console.error('auth: failed');
+  console.error(`login: ${config.loginHint}`);
+  return 1;
+}
+
+function matchCommand(config, args) {
+  return config.commands.find((command) => {
+    if (args.length < command.match.length) return false;
+    return command.match.every((part, index) => args[index] === part);
+  });
+}
+
+function runPassthrough(config, command, args) {
+  const binary = ensureBinary(config);
+  if (!binary.ok) return 1;
+
+  const rest = args.slice(command.match.length);
+  const cliArgs = [...command.forward, ...rest];
+  const result = spawnSync(config.binary, cliArgs, {
+    stdio: 'inherit',
+    env: process.env,
+  });
+  if (missingBinary(result)) {
+    printMissingBinary(config);
+    return 1;
+  }
+  if (result.error) {
+    console.error(`${config.name} command failed: ${result.error.message}`);
+    return 1;
+  }
+  return result.status ?? 0;
+}
+
+function createOfficialCliCommand(config) {
+  return function officialCliCommand(args = []) {
+    const normalizedArgs = Array.isArray(args) ? args : Array.from(arguments);
+    if (normalizedArgs.length === 0 || hasHelp(normalizedArgs)) {
+      printHelp(config);
+      return 0;
+    }
+
+    const subcommand = normalizedArgs[0];
+    const doctorAliases = config.doctorAliases || ['doctor', 'status'];
+    if (doctorAliases.includes(subcommand)) {
+      return printDoctor(config);
+    }
+    if (subcommand === 'auth') {
+      return printAuth(config);
+    }
+
+    const command = matchCommand(config, normalizedArgs);
+    if (!command) {
+      console.error(`unknown ${config.name} command: ${formatCommand(normalizedArgs)}`);
+      console.error(`run: atris ${config.name} --help`);
+      return 1;
+    }
+
+    return runPassthrough(config, command, normalizedArgs);
+  };
+}
+
+module.exports = {
+  createOfficialCliCommand,
+  ensureBinary,
+  hasHelp,
+  matchCommand,
+  printHelp,
+  runAuthCheck,
+};

package/lib/outbound-send-gate.js

@@ -0,0 +1,165 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const {
+  HTML_TAG_RE,
+  RENDERED_SOURCE_FENCE_RE,
+  scanOutboundArtifact,
+} = require('../scripts/outbound-artifact-gate');
+
+const DEFAULT_GATE = Object.freeze({
+  format: 'plain',
+  proofFile: null,
+  bodyFile: null,
+  visual: false,
+  allowSlop: false,
+});
+
+class OutboundArtifactGateError extends Error {
+  constructor(check, file, errors = []) {
+    super(`outbound artifact gate failed: ${check} in ${file}`);
+    this.name = 'OutboundArtifactGateError';
+    this.check = check;
+    this.file = file;
+    this.errors = errors;
+  }
+}
+
+function defaultGateOptions() {
+  return { ...DEFAULT_GATE };
+}
+
+function readOutboundBodyFile(bodyFile) {
+  const file = path.resolve(String(bodyFile || ''));
+  try {
+    return fs.readFileSync(file, 'utf8');
+  } catch {
+    throw new OutboundArtifactGateError('body-file-read-error', file);
+  }
+}
+
+function writeInlineBodyFile(body) {
+  const file = path.join(os.tmpdir(), `atris-outbound-gate-${process.pid}-${Date.now()}.txt`);
+  fs.writeFileSync(file, String(body || ''), { encoding: 'utf8', flag: 'wx' });
+  return file;
+}
+
+function normalizeProofFile(proofFile) {
+  return proofFile ? path.resolve(String(proofFile)) : null;
+}
+
+function extractOutboundGateOptions(args = []) {
+  const rest = [];
+  const gate = defaultGateOptions();
+
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = String(args[i] || '');
+    const eq = arg.indexOf('=');
+    const key = eq >= 0 ? arg.slice(0, eq) : arg;
+    const inlineValue = eq >= 0 ? arg.slice(eq + 1) : null;
+
+    if (key === '--visual') {
+      gate.visual = true;
+      continue;
+    }
+    if (key === '--allow-slop') {
+      gate.allowSlop = true;
+      continue;
+    }
+    if (key === '--format') {
+      gate.format = String(inlineValue !== null ? inlineValue : args[i + 1] || 'plain').toLowerCase();
+      if (inlineValue === null) i += 1;
+      continue;
+    }
+    if (key === '--proof-file' || key === '--render-proof') {
+      gate.proofFile = normalizeProofFile(inlineValue !== null ? inlineValue : args[i + 1]);
+      if (inlineValue === null) i += 1;
+      continue;
+    }
+    if (key === '--body-file') {
+      gate.bodyFile = path.resolve(String(inlineValue !== null ? inlineValue : args[i + 1] || ''));
+      if (inlineValue === null) i += 1;
+      continue;
+    }
+
+    rest.push(arg);
+  }
+
+  return { args: rest, gate };
+}
+
+function parseOutboundSendArgs(args = []) {
+  const parsed = extractOutboundGateOptions(args);
+  return {
+    text: parsed.gate.bodyFile ? '' : parsed.args.join(' ').trim(),
+    gate: parsed.gate,
+  };
+}
+
+function shouldRunOutboundGate(channel, body, gate = {}) {
+  const format = String(gate.format || 'plain').toLowerCase();
+  if (format !== 'plain') return true;
+  if (gate.visual || gate.proofFile || gate.bodyFile) return true;
+  return HTML_TAG_RE.test(body) || RENDERED_SOURCE_FENCE_RE.test(body);
+}
+
+function assertOutboundSendAllowed(channel, body, gate = {}) {
+  const options = { ...defaultGateOptions(), ...(gate || {}) };
+  options.format = String(options.format || 'plain').toLowerCase();
+  options.channel = String(channel || 'other').toLowerCase();
+  options.proofFile = normalizeProofFile(options.proofFile);
+  if (options.bodyFile) options.bodyFile = path.resolve(String(options.bodyFile));
+
+  const inspectedBody = options.bodyFile ? readOutboundBodyFile(options.bodyFile) : String(body || '');
+  if (!shouldRunOutboundGate(options.channel, inspectedBody, options)) {
+    return { ok: true, inspected: false, body: inspectedBody, file: null };
+  }
+
+  const inspectedFile = options.bodyFile || writeInlineBodyFile(inspectedBody);
+  const errors = scanOutboundArtifact({
+    channel: options.channel,
+    format: options.format,
+    bodyFile: inspectedFile,
+    proofFile: options.proofFile,
+    visual: options.visual,
+    allowSlop: options.allowSlop,
+  }, inspectedBody);
+
+  if (errors.length) {
+    throw new OutboundArtifactGateError(errors[0].id, inspectedFile, errors);
+  }
+
+  return { ok: true, inspected: true, body: inspectedBody, file: inspectedFile };
+}
+
+function exitOutboundGateFailure(error) {
+  console.error(error.message);
+  process.exit(1);
+}
+
+function assertOutboundSendAllowedOrExit(channel, body, gate = {}, options = {}) {
+  try {
+    return assertOutboundSendAllowed(channel, body, gate);
+  } catch (error) {
+    exitOutboundGateFailure(error, options);
+  }
+}
+
+function prepareOutboundSendTextOrExit(channel, args = [], options = {}) {
+  const parsed = parseOutboundSendArgs(args);
+  return assertOutboundSendAllowedOrExit(channel, parsed.text, parsed.gate, options);
+}
+
+module.exports = {
+  OutboundArtifactGateError,
+  assertOutboundSendAllowed,
+  assertOutboundSendAllowedOrExit,
+  defaultGateOptions,
+  extractOutboundGateOptions,
+  parseOutboundSendArgs,
+  prepareOutboundSendTextOrExit,
+  readOutboundBodyFile,
+  shouldRunOutboundGate,
+};