atris 3.53.0 → 3.55.0

package/commands/doctor.js

@@ -0,0 +1,174 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const {
+  inspectInstallGitState,
+  formatCliVersionLine,
+  isGitCheckout,
+} = require('../utils/update-check');
+
+const TASK_NODE_MAJOR = 22;
+
+function parseNodeVersion(raw = process.version) {
+  const match = String(raw || '').match(/v?(\d+)\.(\d+)\.(\d+)/);
+  if (!match) return { raw: String(raw || ''), major: 0, minor: 0, patch: 0 };
+  return {
+    raw: String(raw || ''),
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+  };
+}
+
+function detectWorkspaceRoot(cwd = process.cwd()) {
+  let current = path.resolve(cwd);
+  for (;;) {
+    if (fs.existsSync(path.join(current, 'atris', 'atris.md'))
+      || fs.existsSync(path.join(current, '.atris'))) {
+      return current;
+    }
+    const parent = path.dirname(current);
+    if (parent === current) return path.resolve(cwd);
+    current = parent;
+  }
+}
+
+function authState() {
+  try {
+    const { loadCredentials } = require('../utils/auth');
+    const creds = loadCredentials();
+    if (!creds) return { signed_in: false, email: null, source: null };
+    return {
+      signed_in: true,
+      email: creds.email || null,
+      source: process.env.ATRIS_TOKEN ? 'env' : (process.env.ATRIS_PROFILE ? 'profile' : 'credentials'),
+    };
+  } catch {
+    return { signed_in: false, email: null, source: null };
+  }
+}
+
+function publicBinInfo() {
+  const shimPath = path.join(__dirname, '..', 'bin', 'atris');
+  const entryPath = path.join(__dirname, '..', 'bin', 'atris.js');
+  let shimBytes = null;
+  try { shimBytes = fs.statSync(shimPath).size; } catch { shimBytes = null; }
+  let entryBytes = null;
+  try { entryBytes = fs.statSync(entryPath).size; } catch { entryBytes = null; }
+  return {
+    public_bin: 'bin/atris',
+    shim: Boolean(shimBytes != null && shimBytes < 2048),
+    shim_bytes: shimBytes,
+    entry: 'bin/atris.js',
+    entry_bytes: entryBytes,
+    note: 'public bin is a tiny POSIX shim that execs node on bin/atris.js',
+  };
+}
+
+function readCliVersion(packageRoot) {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8'));
+    return typeof pkg.version === 'string' ? pkg.version : 'unknown';
+  } catch {
+    return 'unknown';
+  }
+}
+
+function installWarnings(packageRoot) {
+  const warnings = [];
+  if (!isGitCheckout(packageRoot)) return warnings;
+  const state = inspectInstallGitState(packageRoot);
+  if (state.dirty) {
+    warnings.push(`cli install is a dirty git checkout (${state.branch || 'detached'} @ ${state.head || 'unknown'})`);
+  } else if (state.detached) {
+    warnings.push(`cli install is a detached git checkout (@ ${state.head || 'unknown'})`);
+  }
+  return warnings;
+}
+
+function collectDoctor(options = {}) {
+  const packageRoot = options.packageRoot || path.join(__dirname, '..');
+  const node = parseNodeVersion(options.nodeVersion || process.version);
+  const workspace_root = detectWorkspaceRoot(options.cwd || process.cwd());
+  const task_support = node.major >= TASK_NODE_MAJOR;
+  const auth = authState();
+  const bin = publicBinInfo();
+  const cli_runnable = Boolean(process.execPath) && fs.existsSync(path.join(packageRoot, 'bin', 'atris.js'));
+  const version = readCliVersion(packageRoot);
+  const version_line = formatCliVersionLine(version, packageRoot);
+  const install_git = inspectInstallGitState(packageRoot);
+  const warnings = installWarnings(packageRoot);
+  return {
+    ok: true,
+    action: 'doctor',
+    version,
+    version_line,
+    node: {
+      version: node.raw.startsWith('v') ? node.raw : `v${node.raw}`,
+      major: node.major,
+      minor: node.minor,
+      patch: node.patch,
+      exec_path: process.execPath || null,
+    },
+    task_support,
+    task_support_requires: `node ${TASK_NODE_MAJOR}+`,
+    auth,
+    workspace_root,
+    home: os.homedir(),
+    cli_runnable,
+    bin,
+    install_git: {
+      is_git_repo: Boolean(install_git.isGitRepo),
+      dirty: Boolean(install_git.dirty),
+      branch: install_git.branch || null,
+      head: install_git.head || null,
+    },
+    warnings,
+  };
+}
+
+function renderDoctor(payload) {
+  const lines = [];
+  lines.push('atris doctor');
+  lines.push('');
+  lines.push(`version: ${payload.version_line || payload.version}`);
+  lines.push(`node: ${payload.node.version} (${payload.node.exec_path || 'unknown'})`);
+  lines.push(`task support (22+): ${payload.task_support ? 'yes' : 'no'}`);
+  lines.push(`auth: ${payload.auth.signed_in ? `signed in as ${payload.auth.email || 'unknown'}` : 'signed out'}`);
+  lines.push(`workspace: ${payload.workspace_root}`);
+  lines.push(`cli runnable: ${payload.cli_runnable ? 'yes' : 'no'}`);
+  lines.push(`public bin: ${payload.bin.public_bin} (${payload.bin.shim ? `${payload.bin.shim_bytes} byte shim` : 'not a shim'})`);
+  if (payload.warnings && payload.warnings.length) {
+    lines.push('');
+    for (const warning of payload.warnings) lines.push(`warning: ${warning}`);
+  }
+  if (!payload.task_support) {
+    lines.push('');
+    lines.push(`install Node ${TASK_NODE_MAJOR}+ before running atris task.`);
+  }
+  return lines.join('\n');
+}
+
+function doctorCommand(args = [], options = {}) {
+  if (args.includes('--help') || args.includes('-h') || args[0] === 'help') {
+    console.log('Usage: atris doctor [--json]');
+    console.log('');
+    console.log('Reports node version, task-support (22+), auth, workspace root, and whether the CLI can run.');
+    console.log('Public install entry is bin/atris (tiny POSIX shim) -> bin/atris.js.');
+    return 0;
+  }
+  const payload = collectDoctor(options);
+  if (args.includes('--json')) {
+    console.log(JSON.stringify(payload, null, 2));
+  } else {
+    console.log(renderDoctor(payload));
+  }
+  const healthy = payload.cli_runnable && payload.task_support;
+  return healthy ? 0 : 1;
+}
+
+module.exports = {
+  doctorCommand,
+};

package/commands/dream.js

@@ -341,6 +341,13 @@ function showHelp(log = console.log) {
 async function dreamCommand(args = [], root = process.cwd(), options = {}) {
   const log = options.log || console.log;
   if (args.includes('--help') || args.includes('-h') || args[0] === 'help') return showHelp(log);
+  const { refuseHeadlessUnless } = require('../lib/noninteractive');
+  if (refuseHeadlessUnless(args, {
+    allowYes: true,
+    usage: 'Usage: atris dream [--yes]\nHeadless dream needs --yes.',
+  })) {
+    return 2;
+  }
   const result = await runDream(root, options);
   if (result.cards && result.cards.length) {
     const noun = result.cards.length === 1 ? 'card' : 'cards';

package/commands/drill.js

@@ -19,15 +19,42 @@ function assertOk(condition, message) {
   if (!condition) throw new Error(message);
 }
 
+function textFromWriteSync(data, offset, length) {
+  if (Buffer.isBuffer(data)) {
+    const start = Number.isInteger(offset) ? offset : 0;
+    const end = Number.isInteger(length) ? start + length : data.length;
+    return data.toString('utf8', start, end);
+  }
+  return String(data);
+}
+
 async function captureCommand(fn) {
   const originalLog = console.log;
   const originalError = console.error;
   const originalExit = process.exit;
+  const originalWriteSync = fs.writeSync;
   const originalExitCode = process.exitCode;
   const stdout = [];
   const stderr = [];
+  let stdoutWrites = '';
+  let stderrWrites = '';
+  const stdoutFd = process.stdout.fd;
+  const stderrFd = process.stderr.fd;
   console.log = (...args) => stdout.push(args.map(String).join(' '));
   console.error = (...args) => stderr.push(args.map(String).join(' '));
+  fs.writeSync = function captureWriteSync(fd, data, offset, length) {
+    if (fd === stdoutFd || fd === process.stdout.fd) {
+      const text = textFromWriteSync(data, offset, length);
+      stdoutWrites += text;
+      return Buffer.byteLength(text);
+    }
+    if (fd === stderrFd || fd === process.stderr.fd) {
+      const text = textFromWriteSync(data, offset, length);
+      stderrWrites += text;
+      return Buffer.byteLength(text);
+    }
+    return originalWriteSync.apply(this, arguments);
+  };
   process.exitCode = undefined;
   process.exit = (code = 0) => {
     const error = new Error(`process.exit(${code})`);
@@ -37,16 +64,21 @@ async function captureCommand(fn) {
   };
   try {
     const value = await fn();
-    return { value, stdout: stdout.join('\n'), stderr: stderr.join('\n') };
+    return {
+      value,
+      stdout: `${stdout.join('\n')}${stdoutWrites}`,
+      stderr: `${stderr.join('\n')}${stderrWrites}`,
+    };
   } catch (error) {
     if (error && error.isProcessExit) {
-      const output = `${stderr.join('\n')}\n${stdout.join('\n')}`.trim();
+      const output = `${stderr.join('\n')}${stderrWrites}\n${stdout.join('\n')}${stdoutWrites}`.trim();
       error.message = output || `process.exit(${error.exitCode})`;
     }
     throw error;
   } finally {
     console.log = originalLog;
     console.error = originalError;
+    fs.writeSync = originalWriteSync;
     process.exit = originalExit;
     process.exitCode = originalExitCode;
   }

package/commands/engine.js

@@ -24,6 +24,7 @@ const {
   RUNNER_PROFILE_NAMES,
   buildRunnerCommand,
 } = require('../lib/runner-command');
+const { parseScopeFlag } = require('../lib/cli-scope');
 const {
   ENGINE_ROLES,
   ENGINE_DUTIES,
@@ -901,15 +902,18 @@ async function runEngineSeedCommand(args, root, deps = {}) {
   return 0;
 }
 
-function printRoster(root) {
+function printRoster(root, { scope = 'workspace' } = {}) {
   reconcileStaleEngineProbeErrors(root);
   const list = roster(root);
-  const found = list.filter((e) => e.installed).length;
+  const scoped = scope === 'global'
+    ? list
+    : list.filter((engine) => engine.installed || engine.default || engine.health.status === 'ready');
+  const found = scoped.filter((e) => e.installed).length;
   const current = resolveDefaultEngine(root);
   console.log('');
-  console.log(`  engines: ${found} intelligence${found === 1 ? '' : 's'} found`);
+  console.log(`  engines: ${found} intelligence${found === 1 ? '' : 's'} found (${scope})`);
   console.log('');
-  for (const engine of list) {
+  for (const engine of scoped) {
     const mark = engine.default ? '→' : ' ';
     const state = engine.health.status === 'not_installed' ? 'not installed' : engine.health.status.replace(/_/g, ' ');
     const roles = engine.roles.join(',');
@@ -918,12 +922,33 @@ function printRoster(root) {
     if (engine.duty) details.push(`duty: ${engine.duty}`);
     console.log(`      ${details.join('   ')}`);
   }
+  if (scope !== 'global' && list.length > scoped.length) {
+    console.log(`  … ${list.length - scoped.length} not installed hidden (pass --global to list)`);
+  }
   console.log('');
   console.log(`  default: ${current.name}${current.source === 'saved' ? ' (set here)' : current.source === 'env' ? ' (this session)' : ''}`);
   console.log(`  switch:  atris engine <name>   ·   one run: --engine <name> on mission run / autopilot / run`);
   console.log('');
 }
 
+function registryPayload(root, { scope = 'workspace' } = {}) {
+  const current = resolveDefaultEngine(root);
+  const registry = readEngineRegistry(root);
+  const engines = registry.engines.map((engine) => ({
+    ...engine,
+    default: engine.id === current.name,
+  }));
+  const scoped = scope === 'global'
+    ? engines
+    : engines.filter((engine) => engine.installed || engine.default || (engine.health && engine.health.status === 'ready'));
+  return {
+    scope,
+    default: current.name,
+    source: current.source,
+    engines: scoped,
+  };
+}
+
 function chartEngineLabel(engine) {
   const id = String(engine && (engine.id || engine.name) || '').trim();
   const models = Array.isArray(engine && engine.models)
@@ -1057,19 +1082,6 @@ function runSetEngineCommand(args, root) {
   }
 }
 
-function registryPayload(root) {
-  const current = resolveDefaultEngine(root);
-  const registry = readEngineRegistry(root);
-  return {
-    default: current.name,
-    source: current.source,
-    engines: registry.engines.map((engine) => ({
-      ...engine,
-      default: engine.id === current.name,
-    })),
-  };
-}
-
 function parseSetFlag(args) {
   const prefix = '--set=';
   for (let i = 0; i < args.length; i += 1) {
@@ -1491,16 +1503,17 @@ function engineCommand(args = [], deps = {}) {
     return runEngineAskCommand([...shorthandArgs, '--engine', canonical], root, deps.engineAsk || {});
   }
 
-  const json = args.includes('--json');
-  const positional = args.filter((a) => !a.startsWith('--'));
+  const scope = parseScopeFlag(args);
+  const json = scope.args.includes('--json') || args.includes('--json');
+  const positional = scope.args.filter((a) => !a.startsWith('--'));
   const sub = (positional[0] || '').trim();
 
   if (sub === 'login') {
-    return runEngineLoginCommand(args.slice(args.indexOf('login') + 1), root);
+    return runEngineLoginCommand(scope.args.slice(scope.args.indexOf('login') + 1), root);
   }
 
   if (sub === 'seed') {
-    return runEngineSeedCommand(args.slice(args.indexOf('seed') + 1), root);
+    return runEngineSeedCommand(scope.args.slice(scope.args.indexOf('seed') + 1), root);
   }
 
   if (sub === 'seats') {
@@ -1512,32 +1525,37 @@ function engineCommand(args = [], deps = {}) {
   }
 
   if (sub === 'resolve') {
-    return runResolveCommand(args.slice(args.indexOf('resolve') + 1), root);
+    return runResolveCommand(scope.args.slice(scope.args.indexOf('resolve') + 1), root);
   }
 
   if (sub === 'health') {
-    return runHealthCommand(args.slice(args.indexOf('health') + 1), root);
+    return runHealthCommand(scope.args.slice(scope.args.indexOf('health') + 1), root);
   }
 
   if (sub === 'doctor') {
-    return runDoctorCommand(args.slice(args.indexOf('doctor') + 1), root);
+    return runDoctorCommand(scope.args.slice(scope.args.indexOf('doctor') + 1), root);
   }
 
   if (sub === 'set') {
-    return runSetEngineCommand(args.slice(args.indexOf('set') + 1), root);
+    return runSetEngineCommand(scope.args.slice(scope.args.indexOf('set') + 1), root);
   }
 
-  if (sub === 'chart' || args.includes('--chart')) {
+  if (sub === 'chart' || scope.args.includes('--chart') || args.includes('--chart')) {
     printEngineChart(root);
     return 0;
   }
 
-  if (!sub || sub === 'list' || sub === 'status') {
+  if (!sub || sub === 'list' || sub === 'status' || sub === 'help') {
+    if (sub === 'help' || args.includes('--help') || args.includes('-h')) {
+      console.log('\n  atris engine watch [<id>|latest] [--no-follow]\n                           follow one live transcript or list running engine work');
+      console.log('\n  atris engine            roster + current default\n  atris engines --chart   show the fleet as an org chart\n  atris engine list --json full registry: default + engines with tier, roles, fallback, health\n  atris engine set <name> --duty leader|errands|learning [--models "a, b"]\n                           arrange the fleet and save its model policy\n  atris engine resolve <role> [--json]\n                           choose the best ready engine for navigator|executor|validator\n  atris engine health <name> --set ready|not_installed|credit_out\n                           flip runtime health, for example when credits run out\n  atris engine doctor [--json]\n                           probe which engine CLIs are installed here and sync that into health policy\n  atris engine <name>     make that engine the default here\n  atris engine test [name] preflight: run the engine CLI headless, report pass/fail\n  atris engine ask "<question>" --engine <name> [--engine <name> ...]\n                           ask several engines in parallel without allowing edits\n  atris engine ask --jobs <jobs.json>\n                           ask different read-only questions in parallel\n  atris engine validate <receipt-path|latest> [--engine <name>]\n                           check ask answers with a different read-only referee\n  atris engine validate scoreboard\n                           show pass rates by worker engine\n  atris engine dispatch <task-id> [<task-id> ...] --engine cursor|codex [--prompt-file <f>] [--yolo]\n                           one-command claim, worktree, build, verify, ship, ready\n  atris engine login <provider> --yes\n                           upload a local provider CLI login to the backend vault\n  atris engine login <provider> --computer [--seat <name>]\n  atris engine login <provider> --business <id> [--seat <name>]\n                           sign in on an Atris computer by device flow\n  atris engine login --list | --remove <provider>\n                           list or remove vaulted provider logins\n  atris engine seats       show which named accounts are ready to work\n  atris engine seed <provider> --business <id>|--user\n                           push a vaulted login onto an Atris computer\n  atris engine reset      back to the house default\n  --engine <name>         one run on that engine (mission run / autopilot / run)\n');
+      return 0;
+    }
     if (json) {
-      console.log(JSON.stringify(registryPayload(root), null, 2));
+      console.log(JSON.stringify(registryPayload(root, { scope: scope.kind }), null, 2));
       return 0;
     }
-    printRoster(root);
+    printRoster(root, { scope: scope.kind });
     return 0;
   }
 
@@ -1549,12 +1567,6 @@ function engineCommand(args = [], deps = {}) {
     return 0;
   }
 
-  if (sub === 'help') {
-    console.log('\n  atris engine watch [<id>|latest] [--no-follow]\n                           follow one live transcript or list running engine work');
-    console.log('\n  atris engine            roster + current default\n  atris engines --chart   show the fleet as an org chart\n  atris engine list --json full registry: default + engines with tier, roles, fallback, health\n  atris engine set <name> --duty leader|errands|learning [--models "a, b"]\n                           arrange the fleet and save its model policy\n  atris engine resolve <role> [--json]\n                           choose the best ready engine for navigator|executor|validator\n  atris engine health <name> --set ready|not_installed|credit_out\n                           flip runtime health, for example when credits run out\n  atris engine doctor [--json]\n                           probe which engine CLIs are installed here and sync that into health policy\n  atris engine <name>     make that engine the default here\n  atris engine test [name] preflight: run the engine CLI headless, report pass/fail\n  atris engine ask "<question>" --engine <name> [--engine <name> ...]\n                           ask several engines in parallel without allowing edits\n  atris engine ask --jobs <jobs.json>\n                           ask different read-only questions in parallel\n  atris engine validate <receipt-path|latest> [--engine <name>]\n                           check ask answers with a different read-only referee\n  atris engine validate scoreboard\n                           show pass rates by worker engine\n  atris engine dispatch <task-id> [<task-id> ...] --engine cursor|codex [--prompt-file <f>] [--yolo]\n                           one-command claim, worktree, build, verify, ship, ready\n  atris engine login <provider> --yes\n                           upload a local provider CLI login to the backend vault\n  atris engine login <provider> --computer [--seat <name>]\n  atris engine login <provider> --business <id> [--seat <name>]\n                           sign in on an Atris computer by device flow\n  atris engine login --list | --remove <provider>\n                           list or remove vaulted provider logins\n  atris engine seats       show which named accounts are ready to work\n  atris engine seed <provider> --business <id>|--user\n                           push a vaulted login onto an Atris computer\n  atris engine reset      back to the house default\n  --engine <name>         one run on that engine (mission run / autopilot / run)\n');
-    return 0;
-  }
-
   // atris engine <name> — flip the default. An unknown name is a plain user
   // typo, not a crash: report it cleanly (and as JSON on demand) instead of
   // letting setEngine throw a raw stack trace at a new person.

package/commands/errors.js

@@ -2,14 +2,18 @@
  * Errors command for Atris CLI — admin dashboard over atris_error_events.
  *
  * Usage:
- *   atris errors                      List errors from last 24h, grouped by signature
+ *   atris errors                      Local-only by default (no cloud dump)
+ *   atris errors --account            List cloud errors from last 24h
  *   atris errors --hours 72           Widen the window (max 720h / 30d)
  *   atris errors --limit 1000         Raise the raw-event cap for grouping
  *   atris errors show <id>            Full detail (stack trace, message) for one event
  *
- * Requires admin role on the user row.
+ * Requires admin role on the user row for cloud reads.
+ * Account gate: unbound folders need --account (see lib/account-bound.js).
  */
 
+const fs = require('fs');
+const path = require('path');
 const { loadCredentials } = require('../utils/auth');
 const { apiRequestJson } = require('../utils/api');
 
@@ -38,6 +42,44 @@ function extractFlag(args, ...names) {
   return [value, remaining];
 }
 
+function wantsLocal(args) {
+  if (args.includes('--account') || args.includes('--cloud')) return false;
+  // --local is the default; keep the flag recognized for explicit callers.
+  return true;
+}
+
+function listLocalErrors(json) {
+  const localPath = path.join(process.cwd(), '.atris', 'state', 'errors.jsonl');
+  const rows = [];
+  if (fs.existsSync(localPath)) {
+    for (const line of fs.readFileSync(localPath, 'utf8').split('\n')) {
+      if (!line.trim()) continue;
+      try { rows.push(JSON.parse(line)); } catch { /* skip */ }
+    }
+  }
+
+  if (json) {
+    console.log(JSON.stringify({
+      ok: true,
+      scope: 'local',
+      total_events: rows.length,
+      groups: [],
+      note: 'local scope. pass --account for cloud error events.',
+    }, null, 2));
+    return;
+  }
+
+  if (rows.length === 0) {
+    console.log('No local errors. Pass --account for cloud error events.');
+    return;
+  }
+
+  console.log(`Local errors (${rows.length}). Pass --account for cloud error events.\n`);
+  for (const row of rows.slice(0, 20)) {
+    console.log(`  ${row.message || row.error || JSON.stringify(row)}`);
+  }
+}
+
 async function listErrors(args) {
   const [hoursArg, r1] = extractFlag(args, '--hours', '-H');
   const [limitArg, r2] = extractFlag(r1, '--limit', '-L');
@@ -45,6 +87,11 @@ async function listErrors(args) {
   const hours = hoursArg ? parseInt(hoursArg, 10) : 24;
   const limit = limitArg ? parseInt(limitArg, 10) : 500;
 
+  if (wantsLocal(r2)) {
+    listLocalErrors(json);
+    return;
+  }
+
   const token = getToken();
   const result = await apiRequestJson(`/errors?hours=${hours}&limit=${limit}`, {
     method: 'GET',
@@ -64,7 +111,7 @@ async function listErrors(args) {
   const groups = data.groups || [];
 
   if (json) {
-    console.log(JSON.stringify({ ok: true, ...data }, null, 2));
+    console.log(JSON.stringify({ ok: true, scope: 'account', ...data }, null, 2));
     return;
   }
 
@@ -136,12 +183,13 @@ async function showError(errorId) {
 function printHelp() {
   console.log('');
   console.log('Usage:');
-  console.log('  atris errors                         List errors from last 24h, grouped');
-  console.log('  atris errors --hours 72              Widen the window (max 720h / 30d)');
-  console.log('  atris errors --limit 1000            Raise the raw-event cap');
-  console.log('  atris errors show <full-uuid>        Full detail for one event');
+  console.log('  atris errors                         Local errors (default; no cloud dump)');
+  console.log('  atris errors --account               List cloud errors from last 24h');
+  console.log('  atris errors --account --hours 72    Widen the cloud window (max 720h / 30d)');
+  console.log('  atris errors --account --limit 1000  Raise the raw-event cap');
+  console.log('  atris errors show <full-uuid>        Full detail for one cloud event');
   console.log('');
-  console.log('Admin role required.');
+  console.log('Admin role required for cloud reads. Unbound folders need --account.');
   console.log('');
 }
 
@@ -155,6 +203,8 @@ async function errorsCommand() {
   }
 
   if (sub === 'show') {
+    // show is account-scoped detail; require explicit --account in the remaining args
+    // or that the caller already passed the account gate from a bound workspace.
     await showError(args[1]);
     return;
   }

package/commands/experiments.js

@@ -407,6 +407,18 @@ function buildBenchmarkArtifact(name, packDir, options) {
   return { artifact, score };
 }
 
+function recordExperimentRun(experimentId) {
+  const root = process.cwd();
+  const state = daily.readDailyState(root);
+  const today = new Date().toISOString().slice(0, 10);
+  state.last_run_date = today;
+  if (!Array.isArray(state.history)) state.history = [];
+  if (!state.history.includes(experimentId)) {
+    state.history.push(experimentId);
+  }
+  daily.writeDailyState(root, state);
+}
+
 function experimentsRun(name, ...args) {
   const { experimentsDir } = ensureExperimentsFramework();
 
@@ -434,6 +446,7 @@ function experimentsRun(name, ...args) {
       return;
     }
     runPython(loopPath, [], packDir);
+    recordExperimentRun(name);
     return;
   }
 
@@ -447,6 +460,7 @@ function experimentsRun(name, ...args) {
   const { artifact, score } = buildBenchmarkArtifact(name, packDir, options);
   const artifactPath = writeArtifact(packDir, artifact);
   appendResultsRow(path.join(packDir, 'results.tsv'), artifactPath, artifact, score);
+  recordExperimentRun(name);
 
   console.log(`✓ Endstate ${artifact.track} run recorded`);
   console.log(`  artifact: ${path.relative(process.cwd(), artifactPath)}`);