atris 3.33.3 → 3.34.0

package/atris.md

@@ -91,6 +91,23 @@ The same discipline for words. Output stays sharp no matter how bloated the cont
 
 `expected`: this is how an Atris agent writes and builds. Shipping slop or rambling is a failure smell, same as drift or a stale task.
 
+## the ladder
+
+Six primitives, one sentence each. Every agent in every repo holds this model:
+
+- **The Mission** (MISSION.md): the enduring purpose. Never ends. Sits at the top and helps members pick goals.
+- **Goals** (endgame, member goals): direction derived from the Mission. A goal points; it does not commit.
+- **A mission run** (`atris mission`): a goal that signed a contract: objective + owner + verifier + stop condition. Ends in hours or days. Any engine can tick it.
+- **Tasks** (`atris task`): the smallest provable units. Receipts, then human accept.
+- **Members** (`atris member`): the WHO. A role with memory and judgment doing one bounded, proven slice at a time.
+- **Loops** (`atris loops`): the WHEN. Clocks that never finish, only fire. Health is exit 0 on cadence.
+
+In one line: the Mission anchors, goals point, a mission run commits, tasks prove, accepts land; loops fire members to tick mission runs.
+
+Never conflate the two things called "mission": the Mission is permanent purpose; a mission run is a bounded commitment. An agent that mistakes a run for the Mission never stops working on it; one that mistakes the Mission for a run tries to complete it.
+
+Drift smells: a member goal tracing to no Mission is freelancing; a goal that never becomes a mission run is a wish; a run with no goal above it is busywork; a loop deciding what "done" means owns the wrong axis.
+
 ## task source of truth
 
 Use `atris task` as the source of truth for active work. It stores durable local

package/bin/atris.js

@@ -594,6 +594,7 @@ function showHelp() {
   console.log('  console    - Start/attach always-on coding console (tmux daemon)');
   console.log('  soul       - Show, snapshot, or fork workspace identity');
   console.log('  fleet      - Inspect local fleet status');
+  console.log('  loops      - Background loops board: what runs, what died, start/stop');
   console.log('  agent      - Select cloud agent, spawn worker requests, or run `agent doctor`');
   console.log('  chat       - Chat with Atris 2 Fast in this workspace (--agent for cloud agent; or: atris chat scan)');
   console.log('  fast       - Chat with Atris2 Fast');
@@ -975,7 +976,7 @@ const knownCommands = ['init', 'log', 'now', 'radar', 'ctop', 'launchpad', 'stat
                        'clean', 'harvest', 'verify', 'search', 'skill', 'member', 'codex-goal', 'app', 'apps', 'learn', 'lesson', 'plugin', 'experiments', 'receipt', 'proof', 'openclaw', 'pull', 'push', 'live', 'align', 'terminal', 'computer', 'diff', 'business', 'sync', 'youtube',
                        'ingest', 'query', 'lint', 'loop', 'pulse', 'task', 'mission', 'probe', 'worktree', 'land', 'autoland', 'aeo', 'slop', 'strings', 'security-review', 'secure', 'deck', 'site', 'theme', 'card', 'reel', 'improve', 'xp', 'play', 'gm', 'x', 'recap', 'signup', 'clarity', 'moves',
                        'gmail', 'calendar', 'twitter', 'slack', 'imessage', 'integrations', 'setup', 'clean-workspace', 'cw',
-                       'fork', 'browse', 'publish', 'sleep', 'wake', 'feedback', 'errors', 'wiki', 'code-review', 'cr', 'soul', 'fleet', 'compile', 'spaceship', 'truth', 'sign', 'engine', 'engines'];
+                       'fork', 'browse', 'publish', 'sleep', 'wake', 'feedback', 'errors', 'wiki', 'code-review', 'cr', 'soul', 'fleet', 'loops', 'compile', 'spaceship', 'truth', 'sign', 'engine', 'engines'];
 
 // Check if command is an atris.md spec file - triggers welcome visualization
 function isSpecFile(cmd) {
@@ -2267,6 +2268,14 @@ if (command === 'init') {
   require('../commands/fleet').fleet(args)
     .then(() => process.exit(0))
     .catch((err) => { console.error(`\n✗ Error: ${err.message || err}`); process.exit(1); });
+} else if (command === 'loops') {
+  try {
+    require('../commands/loops').loopsCommand(process.argv[3], ...process.argv.slice(4));
+    process.exit(0);
+  } catch (error) {
+    console.error(`\n✗ Error: ${error.message || error}`);
+    process.exit(1);
+  }
 } else if (command === 'spaceship') {
   const args = process.argv.slice(3);
   require('../commands/spaceship').spaceship(args)

package/commands/loops.js

@@ -0,0 +1,212 @@
+/**
+ * atris loops - one view of every background loop: what runs, what died,
+ * what you can start or stop.
+ *
+ *   atris loops              - the board (registry jobs, launchd agents, missions)
+ *   atris loops stop <id>    - disable a registry job or boot out a launchd agent
+ *   atris loops start <id>   - enable a registry job or kickstart a launchd agent
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execSync, spawnSync } = require('child_process');
+
+function heartbeatDir() {
+  return process.env.ATRIS_HEARTBEAT_DIR || path.join(os.homedir(), '.atris', 'heartbeat');
+}
+
+function readJson(filePath, fallback) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return fallback;
+  }
+}
+
+function registryPath() {
+  return path.join(heartbeatDir(), 'registry.json');
+}
+
+function loadRegistry() {
+  const registry = readJson(registryPath(), null);
+  return registry && Array.isArray(registry.jobs) ? registry : { jobs: [] };
+}
+
+function loadRunState() {
+  return readJson(path.join(heartbeatDir(), 'state.json'), {});
+}
+
+function agoText(iso) {
+  const then = Date.parse(iso || '');
+  if (!Number.isFinite(then)) return 'never';
+  const mins = Math.max(0, Math.round((Date.now() - then) / 60000));
+  if (mins < 60) return `${mins}m ago`;
+  const hours = Math.floor(mins / 60);
+  if (hours < 48) return `${hours}h ago`;
+  return `${Math.floor(hours / 24)}d ago`;
+}
+
+function listLaunchdAgents() {
+  let raw = '';
+  try {
+    raw = execSync('launchctl list', { encoding: 'utf8', timeout: 10000 });
+  } catch {
+    return [];
+  }
+  return raw
+    .split('\n')
+    .filter(line => line.includes('com.atris.'))
+    .map(line => {
+      const [pid, exitCode, label] = line.trim().split(/\s+/);
+      return {
+        label,
+        running: pid !== '-',
+        pid: pid !== '-' ? pid : null,
+        lastExit: exitCode,
+      };
+    })
+    .filter(agent => agent.label);
+}
+
+function workspaceMission(cwd) {
+  const goalState = readJson(path.join(cwd, '.atris', 'state', 'atris_goal.json'), null);
+  const goal = goalState && goalState.goal;
+  if (!goal || !goal.objective) return null;
+  const started = Date.parse(goal.created_at || '');
+  const elapsedMins = Number.isFinite(started) ? Math.round((Date.now() - started) / 60000) : null;
+  return {
+    id: goal.mission_id || '?',
+    status: goal.mission_status || '?',
+    objective: String(goal.objective),
+    elapsedMins,
+  };
+}
+
+function showBoard(cwd) {
+  const registry = loadRegistry();
+  const state = loadRunState();
+
+  console.log('background loops');
+  console.log('');
+
+  const enabled = registry.jobs.filter(job => job.enabled !== false && job.disabled !== true);
+  const disabledCount = registry.jobs.length - enabled.length;
+  console.log(`heartbeat registry (${enabled.length} live, ${disabledCount} retired)`);
+  if (!enabled.length) {
+    console.log('  none declared');
+  }
+  for (const job of enabled) {
+    const run = state[job.id] || {};
+    const fails = Number(run.consecutive_fails || 0);
+    const health = fails > 2 ? `${fails} consecutive fails` : fails > 0 ? `${fails} recent fail${fails === 1 ? '' : 's'}` : 'healthy';
+    const cadence = job.cadence_minutes >= 60 ? `${Math.round(job.cadence_minutes / 60)}h` : `${job.cadence_minutes}m`;
+    console.log(`  ${String(job.id).padEnd(22)} every ${String(cadence).padEnd(5)} last ${agoText(run.last_run).padEnd(9)} ${health}`);
+    console.log(`  ${''.padEnd(22)} ${String(job.purpose || '').slice(0, 84)}`);
+  }
+  console.log('');
+
+  const agents = listLaunchdAgents();
+  console.log(`launchd agents (${agents.length})`);
+  for (const agent of agents) {
+    const status = agent.running ? `running pid ${agent.pid}` : `loaded, last exit ${agent.lastExit}`;
+    console.log(`  ${agent.label.padEnd(44)} ${status}`);
+  }
+  if (!agents.length) console.log('  none');
+  console.log('');
+
+  const mission = workspaceMission(cwd);
+  console.log('mission (this workspace)');
+  if (mission) {
+    const elapsed = mission.elapsedMins === null ? '' : ` · ${mission.elapsedMins}m in`;
+    console.log(`  ${mission.id}`);
+    console.log(`  ${mission.status}${elapsed} · ${mission.objective.slice(0, 80)}`);
+  } else {
+    console.log('  none active');
+  }
+  console.log('');
+  console.log('control: atris loops stop <id> · atris loops start <id>');
+  console.log('ids: registry job id, or a com.atris.* launchd label');
+}
+
+function saveRegistry(registry) {
+  const target = registryPath();
+  fs.copyFileSync(target, `${target}.bak`);
+  fs.writeFileSync(target, `${JSON.stringify(registry, null, 2)}\n`);
+}
+
+function setRegistryJob(id, enabled) {
+  const registry = loadRegistry();
+  const job = registry.jobs.find(row => row.id === id);
+  if (!job) return false;
+  job.enabled = enabled;
+  if (enabled) {
+    delete job.disabled;
+    delete job.disabled_reason;
+  } else {
+    job.disabled = true;
+    job.disabled_reason = `stopped via atris loops ${new Date().toISOString().slice(0, 10)}`;
+  }
+  saveRegistry(registry);
+  return true;
+}
+
+function launchdControl(label, action) {
+  const uid = process.getuid();
+  if (action === 'stop') {
+    const result = spawnSync('launchctl', ['bootout', `gui/${uid}/${label}`], { encoding: 'utf8' });
+    return result.status === 0;
+  }
+  const plist = path.join(os.homedir(), 'Library', 'LaunchAgents', `${label}.plist`);
+  if (!fs.existsSync(plist)) return false;
+  const bootstrap = spawnSync('launchctl', ['bootstrap', `gui/${uid}`, plist], { encoding: 'utf8' });
+  if (bootstrap.status === 0) return true;
+  const kick = spawnSync('launchctl', ['kickstart', '-k', `gui/${uid}/${label}`], { encoding: 'utf8' });
+  return kick.status === 0;
+}
+
+function controlLoop(id, action) {
+  const target = String(id || '').trim();
+  if (!target) {
+    console.error(`Usage: atris loops ${action} <id>`);
+    process.exit(1);
+  }
+  if (target.startsWith('com.atris.')) {
+    const ok = launchdControl(target, action);
+    if (!ok) {
+      console.error(`Could not ${action} ${target}. Check: launchctl print gui/$(id -u)/${target}`);
+      process.exit(1);
+    }
+    console.log(`${action === 'stop' ? 'Stopped' : 'Started'} ${target}.`);
+    return;
+  }
+  const ok = setRegistryJob(target, action === 'start');
+  if (!ok) {
+    console.error(`No registry job named "${target}". Run: atris loops`);
+    process.exit(1);
+  }
+  console.log(`${action === 'stop' ? 'Disabled' : 'Enabled'} ${target} in the heartbeat registry (backup written).`);
+}
+
+function loopsCommand(subcommand, ...args) {
+  switch (subcommand) {
+    case undefined:
+    case 'board':
+    case 'list':
+      showBoard(process.cwd());
+      break;
+    case 'stop':
+      controlLoop(args[0], 'stop');
+      break;
+    case 'start':
+      controlLoop(args[0], 'start');
+      break;
+    default:
+      console.log('Loop commands:');
+      console.log('  atris loops              - board: registry jobs, launchd agents, mission');
+      console.log('  atris loops stop <id>    - disable a registry job or stop a launchd agent');
+      console.log('  atris loops start <id>   - enable a registry job or start a launchd agent');
+  }
+}
+
+module.exports = { loopsCommand, showBoard };

package/commands/mission.js

@@ -1632,7 +1632,7 @@ function missionFromArgs(args) {
     '--native-goal-objective',
     '--visible-goal-status',
     '--visible-goal-objective',
-  ], ['--json', '--always-on', '--xp-task', '--agent-xp', '--worktree', '--spend-full-budget', '--use-whole-budget', '--stop-when-done', '--allow-native-goal-supersede', '--supersede-paused-native-goal', '--take-goal-slot']).join(' ').trim();
+  ], ['--json', '--always-on', '--xp-task', '--agent-xp', '--worktree', '--duplicate', '--spend-full-budget', '--use-whole-budget', '--stop-when-done', '--allow-native-goal-supersede', '--supersede-paused-native-goal', '--take-goal-slot']).join(' ').trim();
   if (!objective) {
     exitMissionError('Usage: atris mission start "<objective>" --owner <member> [--verify "..."] [--cadence manual] [--worktree]', 1, wantsJson(args));
   }
@@ -2778,9 +2778,53 @@ function inheritedWorktreeBase(cwd) {
   }
 }
 
+// Dedup gate: the same objective + owner already active anywhere in the
+// workspace family (this store or any worktree's) is reused, never cloned.
+// Born 2026-07-02: an hourly alive loop spawned six identical auto-improver
+// missions in six fresh worktrees in one day — pure token burn. --duplicate
+// is the explicit escape hatch.
+const TWIN_ACTIVE_STATUSES = new Set(['planning', 'ready', 'running']);
+
+function normalizedObjective(text) {
+  return String(text || '').toLowerCase().replace(/\s+/g, ' ').trim();
+}
+
+function findActiveTwinMission(objective, owner, root = process.cwd()) {
+  const wantObjective = normalizedObjective(objective);
+  const wantOwner = String(owner || '').trim().toLowerCase();
+  if (!wantObjective) return null;
+  const candidates = [
+    ...listMissions(root),
+    ...listWorktreeRollupMissions(root),
+  ];
+  for (const m of candidates) {
+    if (!m || !TWIN_ACTIVE_STATUSES.has(m.status)) continue;
+    if (normalizedObjective(m.objective) !== wantObjective) continue;
+    if (String(m.owner || '').trim().toLowerCase() !== wantOwner) continue;
+    return m;
+  }
+  return null;
+}
+
 function startMission(args) {
   const asJson = wantsJson(args);
   const mission = missionFromArgs(args);
+  if (!hasFlag(args, '--duplicate')) {
+    const twin = findActiveTwinMission(mission.objective, mission.owner);
+    if (twin) {
+      printJsonOrText(
+        { ok: true, action: 'mission_reused', reused: true, mission: twin, note: 'an active mission with this objective and owner already exists; resumed instead of cloning (pass --duplicate to force a second one)' },
+        [
+          `Already active: ${twin.id} (${twin.status})`,
+          `Same objective, same owner — reusing it instead of starting a clone.`,
+          `Resume: atris mission run ${twin.id}`,
+          `Really want a second one: re-run with --duplicate`,
+        ],
+        asJson,
+      );
+      return;
+    }
+  }
   // --worktree: bind the mission to its own isolated checkout. We chdir before
   // any state writes so the mission record, baseline sidecar, receipts, and
   // member files all land inside the worktree — ticks run there, and the main

package/lib/fleet.js

@@ -269,6 +269,9 @@ async function runFleetFlight({
   })();
 
   const staffed = assignEngines(staffFlight(readProjectionTasks(root), { slots }), roster);
+  // The receipt path is decided BEFORE landings so each task's ready-proof
+  // can cite it — the proof policy certifies receipt-backed proofs agent-side.
+  const receiptPath = path.join(root, 'atris', 'runs', `fleet-${nowStamp()}.json`);
   const flight = {
     at: new Date().toISOString(),
     root,
@@ -335,7 +338,7 @@ async function runFleetFlight({
     const landed = land({ entry, result });
     if (landed.ok) {
       flight.landed.push({ task: entry.task.display_id, engine: entry.engine });
-      cli(['task', 'ready', String(entry.task.display_id), '--proof', `Built by ${entry.engine} engine in fleet flight, landed via worktree ship gate (rebase-before-ship, verify re-run). Report tail: ${String(result.report || '').slice(-300).replace(/\n/g, ' ')}`, '--as', `fleet-${entry.engine}`]);
+      cli(['task', 'ready', String(entry.task.display_id), '--proof', `Built by ${entry.engine} engine in fleet flight, landed via worktree ship gate (rebase-before-ship, verify re-run). Receipt saved at ${path.relative(root, receiptPath)}. Report tail: ${String(result.report || '').slice(-300).replace(/\n/g, ' ')}`, '--as', `fleet-${entry.engine}`]);
       log(`    ${entry.engine.padEnd(8)} ✓ landed ${entry.task.display_id}`);
     } else {
       flight.paused.push({ task: entry.task.display_id, engine: entry.engine, ...landed });
@@ -343,9 +346,8 @@ async function runFleetFlight({
     }
   }
 
-  const receiptDir = path.join(root, 'atris', 'runs');
-  fs.mkdirSync(receiptDir, { recursive: true });
-  flight.receipt = path.join(receiptDir, `fleet-${nowStamp()}.json`);
+  fs.mkdirSync(path.dirname(receiptPath), { recursive: true });
+  flight.receipt = receiptPath;
   fs.writeFileSync(flight.receipt, `${JSON.stringify(flight, null, 2)}\n`);
   log('');
   log(`  flight over: ${flight.landed.length} landed, ${flight.paused.length} paused · receipt: ${path.relative(root, flight.receipt)}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "atris",
-  "version": "3.33.3",
+  "version": "3.34.0",
   "main": "bin/atris.js",
   "bin": {
     "atris": "bin/atris.js",