atris 3.30.12 → 3.31.0

package/commands/member.js

@@ -2,7 +2,7 @@ const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
 const os = require('os');
-const { execFileSync } = require('child_process');
+const { execFileSync, spawnSync } = require('child_process');
 const { loadCredentials } = require('../utils/auth');
 const { apiRequestJson } = require('../utils/api');
 const { runAliveTick } = require('../lib/member-alive');
@@ -406,39 +406,245 @@ function missionPurpose(paths) {
   };
 }
 
+const MEMBER_RUN_RUNNABLE_STATUSES = new Set(['planning', 'running', 'ready']);
+
+function memberRunMissionMap() {
+  try {
+    return require('./mission').loadMissionMap(process.cwd());
+  } catch {
+    return new Map();
+  }
+}
+
+function memberRunRunnableMissionId(candidateId, missionMap) {
+  const id = String(candidateId || '').trim();
+  if (!id) return '';
+  const mission = missionMap.get(id);
+  // Unknown here can mean a worktree-held mission; let mission run decide.
+  if (!mission) return id;
+  return MEMBER_RUN_RUNNABLE_STATUSES.has(mission.status) ? id : '';
+}
+
+function memberRunOwnedActiveMissionId(name, missionMap) {
+  // Discovery fallback when the member's own pointers are stale: resume the
+  // member's newest moving mission. ready is excluded — it waits for review.
+  const owner = String(name || '').trim().toLowerCase();
+  const candidates = Array.from(missionMap.values())
+    .filter((mission) => String(mission?.owner || '').trim().toLowerCase() === owner)
+    .filter((mission) => mission.status === 'running' || mission.status === 'planning')
+    .filter((mission) => !/^decide and start the next useful mission after:/i.test(String(mission?.objective || '')))
+    .sort((a, b) => {
+      if (a.status !== b.status) return a.status === 'running' ? -1 : 1;
+      return String(b.updated_at || b.created_at || '').localeCompare(String(a.updated_at || a.created_at || ''));
+    });
+  return candidates[0]?.id || '';
+}
+
 function resolveMemberRunMissionId(name, args = []) {
   const override = readFlag(args, '--mission', '') || readFlag(args, '--mission-id', '');
   if (override) return override;
 
   const paths = requireMemberDir(name);
+  const missionMap = memberRunMissionMap();
   const purpose = missionPurpose(paths);
-  if (purpose.runtimeMission?.id) return purpose.runtimeMission.id;
+  const runtimeId = memberRunRunnableMissionId(purpose.runtimeMission?.id, missionMap);
+  if (runtimeId) return runtimeId;
 
   const goals = loadMemberGoals(name, paths);
   const goal = activeGoal(goals);
-  return goal?.mission_id || '';
+  const goalId = memberRunRunnableMissionId(goal?.mission_id, missionMap);
+  if (goalId) return goalId;
+
+  return memberRunOwnedActiveMissionId(paths.storageName || name, missionMap);
+}
+
+const MEMBER_RUN_START_VALUE_FLAGS = [
+  '--mission',
+  '--mission-id',
+  '--owner',
+  '--runner',
+  '--lane',
+  '--cadence',
+  '--verify',
+  '--stop',
+  '--model',
+  '--max-ticks',
+  '--max-wall',
+  '--minutes',
+  '--hours',
+  '--industry',
+  '--domain',
+  '--value',
+  '--outcome',
+  '--truth',
+  '--proof',
+];
+
+const MEMBER_RUN_START_BOOLEAN_FLAGS = [
+  '--json',
+  '--worktree',
+  '--shared-checkout',
+  '--no-worktree',
+  '--always-on',
+  '--xp-task',
+  '--agent-xp',
+  '--spend-full-budget',
+  '--use-whole-budget',
+  '--stop-when-done',
+  '--choose-work',
+  '--auto',
+];
+
+function memberRunMissionText(args = []) {
+  return stripKnownFlags(args, MEMBER_RUN_START_VALUE_FLAGS, MEMBER_RUN_START_BOOLEAN_FLAGS).join(' ').trim();
+}
+
+function cleanMemberRunPhrase(value) {
+  return String(value || '').replace(/\s+/g, ' ').trim();
+}
+
+function memberRunDomain(args = []) {
+  return cleanMemberRunPhrase(readFlag(args, '--industry', '') || readFlag(args, '--domain', '')) || 'this workspace and its users';
+}
+
+function memberRunOutcome(args = []) {
+  return cleanMemberRunPhrase(readFlag(args, '--outcome', '') || readFlag(args, '--value', ''))
+    || 'revenue, reliability, speed, security, workflow clarity, or customer trust';
+}
+
+function memberRunTruthRule(args = []) {
+  return cleanMemberRunPhrase(readFlag(args, '--truth', '') || readFlag(args, '--proof', ''))
+    || 'say what changed, what was checked, and what is still unproven';
+}
+
+function memberRunUsefulTarget() {
+  try {
+    const { nextMoves: pickNextMoves, isGenericInboxPlaceholder } = require('../lib/next-moves');
+    const moves = pickNextMoves(process.cwd(), 5);
+    const candidate = moves.find((move) => {
+      const title = cleanMemberRunPhrase(move?.title);
+      if (!title) return false;
+      if (isGenericInboxPlaceholder(title)) return false;
+      if (/^mission xp\s*:/i.test(title)) return false;
+      if (/^decide and start the next useful mission after:/i.test(title)) return false;
+      return true;
+    });
+    return candidate?.title ? cleanMemberRunPhrase(candidate.title) : '';
+  } catch {
+    return '';
+  }
+}
+
+function memberRunAutoMissionText(name, args = []) {
+  const domain = memberRunDomain(args);
+  const outcome = memberRunOutcome(args);
+  const truth = memberRunTruthRule(args);
+  const target = memberRunUsefulTarget();
+  const work = target
+    ? `Start with this concrete candidate: ${target}.`
+    : 'First inspect current Atris state, then choose one bounded useful task.';
+  return [
+    `Run ${name} on meaningful work for ${domain}.`,
+    work,
+    `Useful means it improves ${outcome}.`,
+    `Truth rule: ${truth}.`,
+    'Explain the choice in plain language, prove the result before Review, and stop instead of doing fake busywork when no useful task exists.',
+  ].join(' ');
+}
+
+function memberRunBudgetSeconds(args = []) {
+  const hours = readNumberFlag(args, '--hours', null);
+  if (Number.isFinite(hours) && hours > 0) return Math.round(hours * 3600);
+  const minutes = readNumberFlag(args, '--minutes', null);
+  if (Number.isFinite(minutes) && minutes > 0) return Math.round(minutes * 60);
+  return null;
+}
+
+function pushFlagValue(out, args, name) {
+  const value = readFlag(args, name, '');
+  if (value) out.push(name, String(value));
+}
+
+function pushFlagWhenPresent(out, args, name) {
+  if (hasFlag(args, name)) out.push(name);
+}
+
+function startMemberRunMission(name, missionText, args = []) {
+  const paths = requireMemberDir(name);
+  const owner = paths.storageName || name;
+  const startArgs = [
+    'mission',
+    'start',
+    missionText,
+    '--owner',
+    owner,
+    '--runner',
+    readFlag(args, '--runner', 'codex_goal'),
+    '--lane',
+    readFlag(args, '--lane', 'workspace'),
+  ];
+  pushFlagValue(startArgs, args, '--cadence');
+  pushFlagValue(startArgs, args, '--verify');
+  pushFlagValue(startArgs, args, '--stop');
+  pushFlagValue(startArgs, args, '--model');
+  pushFlagValue(startArgs, args, '--max-wall');
+  pushFlagValue(startArgs, args, '--minutes');
+  pushFlagValue(startArgs, args, '--hours');
+  pushFlagValue(startArgs, args, '--base');
+  pushFlagWhenPresent(startArgs, args, '--always-on');
+  pushFlagWhenPresent(startArgs, args, '--xp-task');
+  pushFlagWhenPresent(startArgs, args, '--agent-xp');
+  pushFlagWhenPresent(startArgs, args, '--spend-full-budget');
+  pushFlagWhenPresent(startArgs, args, '--use-whole-budget');
+  pushFlagWhenPresent(startArgs, args, '--stop-when-done');
+  if (!hasFlag(args, '--shared-checkout') && !hasFlag(args, '--no-worktree')) startArgs.push('--worktree');
+  if (hasFlag(args, '--json')) startArgs.push('--json');
+
+  const cliPath = path.join(__dirname, '..', 'bin', 'atris.js');
+  try {
+    execFileSync(process.execPath, [cliPath, ...startArgs], {
+      cwd: process.cwd(),
+      stdio: 'inherit',
+    });
+  } catch (error) {
+    process.exitCode = Number(error?.status) || 1;
+  }
 }
 
 function memberRun(name, ...args) {
   if (!name || name === '--help' || name === '-h' || hasFlag(args, '--help') || hasFlag(args, '-h')) {
-    console.log('Usage: atris member run <name> [mission run flags]');
-    console.log('Example: atris member run block-builder --max-ticks 1 --max-wall 900 --json');
-    console.log('Override: atris member run block-builder --mission <mission-id> --json');
+    console.log('Usage: atris member run <name> ["mission text"] [--minutes N|--hours N] [--json]');
+    console.log('New mission: atris member run growth "Improve onboarding proof" --minutes 30 --json');
+    console.log('Choose work: atris member run growth --industry logistics --value "reduce support time" --minutes 30 --json');
+    console.log('Existing mission: atris member run growth --mission <mission-id> --max-ticks 1 --json');
+    console.log('Meaning: if mission text is omitted, the member chooses one useful bounded task from Atris state.');
+    console.log('Truth: useful work must improve revenue, reliability, speed, security, clarity, or trust, then show plain proof.');
+    console.log('Isolation: new missions use --worktree by default; add --shared-checkout to stay here.');
+    return;
+  }
+
+  const missionText = memberRunMissionText(args);
+  const hasMissionOverride = Boolean(readFlag(args, '--mission', '') || readFlag(args, '--mission-id', ''));
+  if (missionText && !hasMissionOverride) {
+    startMemberRunMission(name, missionText, args);
     return;
   }
 
   const missionId = resolveMemberRunMissionId(name, args);
   if (!missionId) {
-    console.error(`No active Mission Runtime found for member "${name}".`);
-    console.error(`Try: atris member goal-from-mission ${name} --json`);
-    console.error(`Or:  atris mission start "..." --owner ${name}`);
-    process.exitCode = 1;
+    startMemberRunMission(name, memberRunAutoMissionText(name, args), args);
     return;
   }
 
-  const runArgs = stripKnownFlags(args, ['--mission', '--mission-id']);
-  if (!readFlag(runArgs, '--max-ticks', '')) runArgs.push('--max-ticks', '1');
-  if (!readFlag(runArgs, '--max-wall', '')) runArgs.push('--max-wall', '900');
+  const runArgs = stripKnownFlags(args, ['--mission', '--mission-id', '--minutes', '--hours'], ['--worktree', '--shared-checkout', '--no-worktree']);
+  const budgetSeconds = memberRunBudgetSeconds(args);
+  // A timed run is a loop contract, not one tick: keep picking the next useful
+  // move until the wall clock (--max-wall) spends the budget. Only untimed runs
+  // default to a single tick.
+  if (!readFlag(runArgs, '--max-ticks', '')) {
+    runArgs.push('--max-ticks', budgetSeconds ? String(Math.max(4, Math.ceil(budgetSeconds / 300))) : '1');
+  }
+  if (!readFlag(runArgs, '--max-wall', '')) runArgs.push('--max-wall', String(budgetSeconds || 900));
 
   const cliPath = path.join(__dirname, '..', 'bin', 'atris.js');
   try {
@@ -2023,6 +2229,247 @@ function memberLoopPaths(name) {
     lockPath: path.join(stateDir, `${name}.lock.json`),
     stopPath: path.join(stateDir, `${name}.stop.json`),
     latestPath: path.join(stateDir, `${name}.latest.json`),
+    cronScriptPath: path.join(stateDir, `${name}.hourly-alive.sh`),
+  };
+}
+
+function memberAliveCronMarker(name) {
+  return `ATRIS_MEMBER_ALIVE_${String(name || '').replace(/[^a-zA-Z0-9]/g, '_').toUpperCase()}`;
+}
+
+function shellSingleQuote(value) {
+  return `'${String(value || '').replace(/'/g, "'\\''")}'`;
+}
+
+function resolveAtrisCommand() {
+  return path.join(__dirname, '..', 'bin', 'atris.js');
+}
+
+function buildMemberAliveCronScript(name, args = [], paths = memberLoopPaths(name)) {
+  const root = process.cwd();
+  const atrisBin = resolveAtrisCommand();
+  const logDir = path.join(paths.stateDir, 'logs');
+  const command = [
+    process.execPath,
+    atrisBin,
+    'member',
+    'alive',
+    name,
+    '--hourly',
+    '--forever',
+    '--ticks',
+    '1',
+    '--json',
+    ...(hasFlag(args, '--execute') ? ['--execute'] : []),
+    ...(hasFlag(args, '--confirm-autonomy-policy') ? ['--confirm-autonomy-policy'] : []),
+  ];
+  const agent = String(readFlag(args, '--agent', '') || '').trim();
+  const model = String(readFlag(args, '--model', '') || '').trim();
+  const maxWall = String(readFlag(args, '--operate-max-wall', readFlag(args, '--max-wall', '')) || '').trim();
+  const autoAcceptLimit = String(readFlag(args, '--auto-accept-limit', '') || '').trim();
+  if (agent) command.push('--agent', agent);
+  if (model) command.push('--model', model);
+  if (maxWall) command.push('--operate-max-wall', maxWall);
+  if (autoAcceptLimit) command.push('--auto-accept-limit', autoAcceptLimit);
+  const renderedCommand = command.map(shellSingleQuote).join(' ');
+  return {
+    command,
+    rendered_command: renderedCommand,
+    script: [
+      '#!/bin/zsh',
+      'set -u',
+      `ROOT=${shellSingleQuote(root)}`,
+      `LOG_DIR=${shellSingleQuote(logDir)}`,
+      'mkdir -p "$LOG_DIR"',
+      'stamp="$(date +"%Y%m%d-%H%M%S")"',
+      'cd "$ROOT" || exit 1',
+      'export ATRIS_SKIP_UPDATE_CHECK=1',
+      `${renderedCommand} >> "$LOG_DIR/$stamp.log" 2>&1`,
+      'echo "done: $(date -Iseconds) exit=$?" >> "$LOG_DIR/$stamp.log"',
+      '',
+    ].join('\n'),
+  };
+}
+
+function memberAliveCronCadence(args = []) {
+  const pulse = require('../lib/pulse');
+  const raw = hasFlag(args, '--hourly') || hasFlag(args, '--every-hour')
+    ? 'hourly'
+    : readFlag(args, '--cadence', readFlag(args, '--cron', readFlag(args, '--interval', 'hourly')));
+  return pulse.normalizeCronCadence(raw);
+}
+
+function buildMemberAliveCrontabLine(name, args = [], paths = memberLoopPaths(name)) {
+  return `${memberAliveCronCadence(args)} ${paths.cronScriptPath} # ${memberAliveCronMarker(name)}`;
+}
+
+function dirtyGitStatus(root = process.cwd()) {
+  const result = spawnSync('git', ['status', '--porcelain'], { cwd: root, encoding: 'utf8', timeout: 10000 });
+  if (result.status !== 0) {
+    return { inside_git: false, dirty: false, dirty_count: 0, dirty_files: [] };
+  }
+  const dirtyFiles = String(result.stdout || '')
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean);
+  return {
+    inside_git: true,
+    dirty: dirtyFiles.length > 0,
+    dirty_count: dirtyFiles.length,
+    dirty_files: dirtyFiles.slice(0, 12),
+  };
+}
+
+function memberAliveInstallPreview(name, args = [], paths = memberLoopPaths(name), script = buildMemberAliveCronScript(name, args, paths)) {
+  return {
+    schema: 'atris.member_alive_install_preview.v1',
+    member: name,
+    cadence: memberAliveCronCadence(args),
+    mission_text: memberRunAutoMissionText(name, args),
+    run: script.rendered_command,
+    verify: `atris member alive ${name} --status --json`,
+    stop_when: `Run atris member alive ${name} --uninstall, or create the stop marker at ${paths.stopPath}.`,
+    receipts: path.join(paths.stateDir, 'logs'),
+  };
+}
+
+function memberAliveInstallPreviewLines(preview) {
+  return [
+    'Every hour this will:',
+    `  run: ${preview.run}`,
+    `  verify: ${preview.verify}`,
+    `  stop when: ${preview.stop_when}`,
+    `  receipts: ${preview.receipts}`,
+  ];
+}
+
+function installMemberAliveCron(name, args = []) {
+  const asJson = hasFlag(args, '--json');
+  const dryRun = hasFlag(args, '--dry-run');
+  if (hasFlag(args, '--execute') && !hasFlag(args, '--confirm-autonomy-policy')) {
+    const payload = {
+      ok: false,
+      action: 'alive_install',
+      member: name,
+      status: 'blocked',
+      reason: 'execute_requires_confirm_autonomy_policy',
+    };
+    printJsonOrText(payload, [
+      `Install blocked for ${name}: execute requires --confirm-autonomy-policy.`,
+    ], asJson);
+    process.exitCode = 1;
+    return payload;
+  }
+  const paths = memberLoopPaths(name);
+  fs.mkdirSync(paths.stateDir, { recursive: true });
+  const script = buildMemberAliveCronScript(name, args, paths);
+  const crontabLine = buildMemberAliveCrontabLine(name, args, paths);
+  const preview = memberAliveInstallPreview(name, args, paths, script);
+  if (hasFlag(args, '--execute') && !dryRun) {
+    const gitStatus = dirtyGitStatus();
+    if (gitStatus.dirty) {
+      const payload = {
+        ok: false,
+        action: 'alive_install',
+        member: name,
+        status: 'blocked',
+        reason: 'install_requires_clean_git',
+        git: gitStatus,
+        preview,
+      };
+      printJsonOrText(payload, [
+        `Install blocked for ${name}: commit or clean local changes before installing an execute loop.`,
+        ...memberAliveInstallPreviewLines(preview),
+      ], asJson);
+      process.exitCode = 1;
+      return payload;
+    }
+  }
+  fs.writeFileSync(paths.cronScriptPath, script.script, { mode: 0o755 });
+  const marker = memberAliveCronMarker(name);
+  let installed = false;
+  let error = null;
+  if (!dryRun) {
+    const existing = spawnSync('crontab', ['-l'], { encoding: 'utf8', timeout: 10000 });
+    const current = existing.status === 0 ? existing.stdout : '';
+    const kept = String(current || '').split(/\r?\n/).filter((line) => line.trim() && !line.includes(marker));
+    const next = `${kept.join('\n')}${kept.length ? '\n' : ''}${crontabLine}\n`;
+    const apply = spawnSync('crontab', ['-'], { input: next, encoding: 'utf8', timeout: 10000 });
+    installed = apply.status === 0;
+    if (!installed) error = apply.stderr || `crontab exited ${apply.status}`;
+  }
+  const payload = {
+    ok: dryRun || installed,
+    action: 'alive_install',
+    member: name,
+    cadence: 'hourly',
+    forever: true,
+    installed,
+    dry_run: dryRun,
+    script_path: paths.cronScriptPath,
+    crontab_line: crontabLine,
+    command: script.command,
+    preview,
+    stop_command: `atris member alive ${name} --uninstall`,
+    error,
+  };
+  writeJsonFile(paths.latestPath, payload);
+  printJsonOrText(payload, [
+    `${dryRun ? 'Would install' : installed ? 'Installed' : 'Install failed'} hourly alive loop: ${name}`,
+    `Cron: ${crontabLine}`,
+    ...memberAliveInstallPreviewLines(preview),
+    `Stop: ${payload.stop_command}`,
+  ], asJson);
+  if (!payload.ok) process.exitCode = 1;
+  return payload;
+}
+
+function uninstallMemberAliveCron(name, args = []) {
+  const asJson = hasFlag(args, '--json');
+  const paths = memberLoopPaths(name);
+  const marker = memberAliveCronMarker(name);
+  const existing = spawnSync('crontab', ['-l'], { encoding: 'utf8', timeout: 10000 });
+  if (existing.status !== 0) {
+    const payload = { ok: true, action: 'alive_uninstall', member: name, removed: false, reason: 'no_crontab' };
+    printJsonOrText(payload, [`No hourly alive crontab found for ${name}.`], asJson);
+    return payload;
+  }
+  const before = String(existing.stdout || '').split(/\r?\n/);
+  const after = before.filter((line) => !line.includes(marker));
+  const removed = after.length !== before.length;
+  const apply = spawnSync('crontab', ['-'], { input: after.filter(Boolean).join('\n') + (after.filter(Boolean).length ? '\n' : ''), encoding: 'utf8', timeout: 10000 });
+  const payload = {
+    ok: apply.status === 0,
+    action: 'alive_uninstall',
+    member: name,
+    removed,
+    marker,
+    script_path: paths.cronScriptPath,
+    error: apply.status === 0 ? null : apply.stderr || `crontab exited ${apply.status}`,
+  };
+  printJsonOrText(payload, [
+    removed ? `Removed hourly alive loop: ${name}` : `No hourly alive line found for ${name}.`,
+  ], asJson);
+  if (!payload.ok) process.exitCode = 1;
+  return payload;
+}
+
+function memberAliveCronStatus(name, paths = memberLoopPaths(name)) {
+  const marker = memberAliveCronMarker(name);
+  let crontabLine = null;
+  const crontab = spawnSync('crontab', ['-l'], { encoding: 'utf8', timeout: 10000 });
+  if (crontab.status === 0) {
+    crontabLine = String(crontab.stdout || '').split(/\r?\n/).find((line) => line.includes(marker)) || null;
+  }
+  return {
+    schema: 'atris.member_alive_cron_status.v1',
+    marker,
+    installed: Boolean(crontabLine),
+    crontab_line: crontabLine,
+    script_path: paths.cronScriptPath,
+    script_exists: fs.existsSync(paths.cronScriptPath),
+    install_command: `atris member alive ${name} --install --hourly --forever --execute --confirm-autonomy-policy --json`,
+    uninstall_command: `atris member alive ${name} --uninstall`,
   };
 }
 
@@ -2145,6 +2592,11 @@ function stripAutoImproverTitleNoise(text) {
 function isAutoImproverGeneratedLogLine(line, relativePath = '') {
   const text = String(line || '').trim();
   if (!text) return false;
+  if (/^[-*]?\s*Next tick will stop until a human looks at the error\.?$/i.test(text)) return true;
+  if (/^[-*]?\s*Next tick will verify failed, halting\.?$/i.test(text)) return true;
+  if (/^##\s+\d{1,2}:\d{2}\s+·\s+Task failed$/i.test(text)) return true;
+  if (/^[-*]?\s*(status|action|state|verifier)\s*:\s*(failed|blocked)\s*$/i.test(text)) return true;
+  if (/^[-*]?\s*(title|proof):\s*/i.test(text)) return true;
   if (String(relativePath || '').startsWith('atris/team/auto-improver/logs/') && /^-\s*summary:\s*/i.test(text)) return true;
   if (/\bauto[- ]improver\b/i.test(text) && /\b(dogfood|receipt|prevented|pain_)\b/i.test(text)) return true;
   if (/\bauto_improver\b/i.test(text)) return true;
@@ -2162,12 +2614,28 @@ function normalizeFailurePattern(line) {
     .trim());
 }
 
+function failureCoveredByPassLesson(line, passLessonText = '') {
+  const text = String(line || '');
+  if (!text || !passLessonText) return false;
+  if (/spawnSync\s+\/bin\/sh\s+ETIMEDOUT/i.test(text)) {
+    const target = text.match(/"([^"]+)"/)?.[1] || '';
+    const targetTail = target ? target.split('/').slice(-2).join('/') : '';
+    return /spawnSync\s+\/bin\/sh\s+ETIMEDOUT/i.test(passLessonText)
+      && (!target || passLessonText.includes(target) || (targetTail && passLessonText.includes(targetTail)));
+  }
+  return false;
+}
+
 function collectAutoImproverLogSignals(root) {
   const roots = [
     path.join(root, 'atris', 'logs'),
     path.join(root, 'atris', 'team'),
     path.join(root, 'atris', 'wiki'),
   ].filter((candidate) => fs.existsSync(candidate));
+  const passLessonText = safeReadText(path.join(root, 'atris', 'lessons.md'), 500000)
+    .split(/\r?\n/)
+    .filter((line) => /\s+pass\s+—/.test(line))
+    .join('\n');
   const failureRegex = /\b(error|failed|failure|blocked|timeout|regression|crash|missing proof|naraka|suffering)\b/i;
   const unclearRegex = /\b(tbd|unclear|unknown|needs user|needs owner|needs proof|no next|blocked)\b/i;
   const counts = new Map();
@@ -2203,6 +2671,7 @@ function collectAutoImproverLogSignals(root) {
         if (/^\s*[-*]?\s*check:\s/i.test(line)) continue;
         if (/\b(errors?|fail(?:ed|ures?)|blocked|timeouts?)\s*:\s*0\b/i.test(line)) continue;
         if (/\bblocked\s*(?:->|→|to)\s*ready\b/i.test(line)) continue;
+        if (failureCoveredByPassLesson(line, passLessonText)) continue;
         if (unclearRegex.test(line)) {
           unclearNextActions += 1;
           unclearActions.push({
@@ -6900,6 +7369,14 @@ async function memberLoop(name, ...args) {
   const paths = memberLoopPaths(name);
   fs.mkdirSync(paths.stateDir, { recursive: true });
 
+  if (hasFlag(args, '--install')) {
+    return installMemberAliveCron(name, args);
+  }
+
+  if (hasFlag(args, '--uninstall')) {
+    return uninstallMemberAliveCron(name, args);
+  }
+
   if (status) {
     const active = readJsonIfExists(paths.lockPath);
     const latest = readJsonIfExists(paths.latestPath);
@@ -6910,12 +7387,14 @@ async function memberLoop(name, ...args) {
       active: Boolean(active && Number(active.expires_at_ms || 0) > Date.now() && isPidAlive(active.pid)),
       lease: active || null,
       latest: latest || null,
+      hourly_alive: memberAliveCronStatus(name, paths),
       lock_path: paths.lockPath,
       latest_path: paths.latestPath,
     };
     printJsonOrText(payload, [
       `Loop status: ${name}`,
       `Active: ${payload.active ? 'yes' : 'no'}`,
+      `Hourly: ${payload.hourly_alive.installed ? 'installed' : payload.hourly_alive.script_exists ? 'script ready' : 'not installed'}`,
       `Latest: ${latest?.receipt_path ? path.relative(process.cwd(), latest.receipt_path) : 'none'}`,
     ], asJson);
     return;
@@ -6953,11 +7432,21 @@ async function memberLoop(name, ...args) {
   const ticksFlag = readNumberFlag(args, '--ticks', null);
   const minutes = readNumberFlag(args, '--minutes', null);
   const durationSeconds = readNumberFlag(args, '--duration-seconds', readNumberFlag(args, '--seconds', null));
-  const intervalSeconds = readNumberFlag(args, '--interval', readNumberFlag(args, '--interval-seconds', 60));
+  const hourly = hasFlag(args, '--hourly') || hasFlag(args, '--every-hour');
+  const forever = hasFlag(args, '--forever') || hasFlag(args, '--until-stopped');
+  const intervalSeconds = hourly
+    ? 3600
+    : readNumberFlag(args, '--interval', readNumberFlag(args, '--interval-seconds', 60));
   const intervalMs = Math.max(0, Math.floor(Number(intervalSeconds == null ? 60 : intervalSeconds) * 1000));
-  const durationMs = Math.max(0, Math.floor(durationSeconds != null ? Number(durationSeconds) * 1000 : Number(minutes == null ? 10 : minutes) * 60 * 1000));
+  const durationMs = forever && ticksFlag == null
+    ? 0
+    : Math.max(0, Math.floor(durationSeconds != null ? Number(durationSeconds) * 1000 : Number(minutes == null ? 10 : minutes) * 60 * 1000));
   const ticks = ticksFlag != null
     ? Math.max(1, Math.floor(Number(ticksFlag)))
+    : forever
+      ? execute && confirmed
+        ? Number.MAX_SAFE_INTEGER
+        : 1
     : intervalMs > 0
       ? Math.max(1, Math.floor(durationMs / intervalMs))
       : 1;
@@ -6967,7 +7456,7 @@ async function memberLoop(name, ...args) {
   const ttlMs = Math.max(
     30000,
     Math.floor(Number(ttlSeconds == null ? 0 : ttlSeconds) * 1000),
-    durationMs + 60000,
+    forever ? intervalMs + (2 * 60 * 60 * 1000) : durationMs + 60000,
     intervalMs + 60000,
   );
 
@@ -7162,6 +7651,12 @@ async function memberLoop(name, ...args) {
     alive: aliveMode,
     status: failed ? 'failed' : stopped ? 'stopped' : earlyExit ? (earlyExit.blocked_on_human ? 'blocked_on_human' : 'idle') : 'completed',
     mode: execute ? 'execute' : 'dry_run',
+    cadence: hourly ? 'hourly' : 'custom',
+    forever,
+    stop_command: `atris member ${aliveMode ? 'alive' : 'loop'} ${name} --stop`,
+    operating_contract: forever
+      ? 'Run on this cadence until stopped; each tick must choose useful work, prove it plainly, or stop/ask instead of faking activity.'
+      : 'Run for the requested bounded window; each tick must choose useful work, prove it plainly, or stop/ask instead of faking activity.',
     run_id: runId,
     ticks_requested: ticks,
     ticks: tickResults.length,
@@ -7191,8 +7686,10 @@ async function memberLoop(name, ...args) {
   printJsonOrText(payload, [
     `${aliveMode ? 'Alive' : 'Loop'}: ${name}`,
     `Status: ${payload.status}`,
+    `Cadence: ${payload.cadence}${payload.forever ? ' forever' : ''}`,
     `Ticks: ${payload.ticks}/${payload.ticks_requested}`,
     `Decisions: ${Object.entries(decisions).map(([key, count]) => `${key} x${count}`).join(', ') || 'none'}`,
+    `Stop: ${payload.stop_command}`,
     `Receipt: ${path.relative(process.cwd(), receiptPath)}`,
   ], asJson);
 }
@@ -7533,7 +8030,7 @@ async function memberCommand(subcommand, ...args) {
   // Subcommands that take a member name as args[0] otherwise treat `--help` as
   // a name and error with "Member '--help' not found". `create`/`new` handle
   // help themselves (with subcommand-specific usage) — leave those alone.
-  const HELP_AWARE_SUBCOMMANDS = new Set(['create', 'new']);
+  const HELP_AWARE_SUBCOMMANDS = new Set(['create', 'new', 'run']);
   if (!HELP_AWARE_SUBCOMMANDS.has(subcommand) && (args[0] === '-h' || args[0] === '--help')) {
     subcommand = undefined;
   }
@@ -7603,7 +8100,7 @@ async function memberCommand(subcommand, ...args) {
       console.log('  goal-from-mission <name>  Create/reuse a goal from MISSION.md and now.md');
       console.log('  goal-from-score <name>    Create/reuse an active goal from Team score evidence');
       console.log('  wake <name>         Read Mission state and decide tick/wait/ask/stop');
-      console.log("  run <name>          Run the member's active Mission Runtime");
+      console.log('  run <name> ["..."]  Start a budgeted member mission, or run its active Mission Runtime');
       console.log('  loop <name>         Repeat wake on a bounded cadence with a no-overlap lease');
       console.log('  tick <name>         Propose the next bounded experiment');
       console.log('  review <name> <id>  Accept/discard an experiment with proof');
@@ -7633,13 +8130,16 @@ async function memberCommand(subcommand, ...args) {
       console.log('  atris member goal-from-mission growth --json');
       console.log('  atris member goal-from-score growth --score-json team-score.json --json');
       console.log('  atris member wake growth --json');
-      console.log('  atris member run growth --max-ticks 1 --max-wall 900 --json');
+      console.log('  atris member run growth "Improve onboarding proof" --minutes 30 --json');
+      console.log('  atris member run growth --mission <mission-id> --max-ticks 1 --json');
       console.log('  atris member wake growth --execute --confirm-autonomy-policy');
       console.log('  atris member supervisor recommendations --json');
       console.log('  atris member objective-generator proposals --json');
       console.log('  atris member generalist proof --json');
       console.log('  atris member generalist patterns --json');
       console.log('  atris member loop growth --minutes 10 --interval 60 --json');
+      console.log('  atris member alive growth --hourly --forever --execute --confirm-autonomy-policy --json');
+      console.log('  atris member alive growth --install --hourly --forever --execute --confirm-autonomy-policy --json');
       console.log('  atris member alive growth --minutes 480 --interval 900 --execute --confirm-autonomy-policy --json');
       console.log('  atris member loop growth --ticks 2 --interval 0 --json');
       console.log('  atris member tick growth --json');