atris 3.34.0 → 3.36.0

package/commands/play.js

@@ -328,6 +328,7 @@ function playWorkspaceRoot(taskDb, workspaceArg) {
 
 function nextCommands(task, player) {
   const helper = player || 'player';
+  const readyResult = 'Players can now claim AgentXP proof faster because the verifier names the finished artifact.';
   if (!task) {
     return [
       `atris task delegate "AgentXP first rep: one proof-backed mission" --to ${player} --tag agent-xp`,
@@ -339,7 +340,7 @@ function nextCommands(task, player) {
   if (task.status === 'open') {
     return [
       `atris task claim ${ref} --as ${helper}`,
-      `atris task ready ${ref} --as ${helper} --proof "AGENTXP_PROOF.md + test -s AGENTXP_PROOF.md passed"`,
+      `atris task ready ${ref} --as ${helper} --proof "AGENTXP_PROOF.md + test -s AGENTXP_PROOF.md passed" --result "${readyResult}"`,
       `atris task accept ${ref} --as ${player} --proof "<human review>"`,
       'atris xp card --local',
       ...globalSyncCommands(player),
@@ -349,7 +350,7 @@ function nextCommands(task, player) {
   if (task.status === 'claimed') {
     const actor = task.claimed_by || helper;
     return [
-      `atris task ready ${ref} --as ${actor} --proof "AGENTXP_PROOF.md + test -s AGENTXP_PROOF.md passed"`,
+      `atris task ready ${ref} --as ${actor} --proof "AGENTXP_PROOF.md + test -s AGENTXP_PROOF.md passed" --result "${readyResult}"`,
       `atris task accept ${ref} --as ${player} --proof "<human review>"`,
       'atris xp card --local',
       ...globalSyncCommands(player),

package/commands/probe.js

@@ -28,6 +28,7 @@ const https = require('https');
 const http = require('http');
 const { getApiBaseUrl } = require('../utils/api');
 const { loadCredentials } = require('../utils/auth');
+const { encodeToolResult } = require('../lib/tool-result-encode');
 
 // G2's honest blocked message (tool_policy_bench.MAX_TURNS_EXHAUSTED_MESSAGE)
 // starts with this — an answer that is only this marker is a dead-end.
@@ -182,6 +183,26 @@ function runTerminal(base, token, command, businessId) {
   return postJson(`${base}/ai-computer/terminal`, token, body, 80000);
 }
 
+// CLI-231: local executor for atris2 mission ticks. Same result shape as the
+// /ai-computer/terminal endpoint ({ stdout, stderr, exit_code }), but the
+// command runs in the mission's OWN workspace directory instead of the hosted
+// ai-computer. Without this, a mission tick in a local workspace read the
+// remote computer's files and reported local members (e.g. maze) as missing.
+function runLocalTerminal(command, cwd) {
+  const { exec } = require('child_process');
+  const { envWithNodeDir } = require('../lib/spawn-env');
+  const env = envWithNodeDir(process.env);
+  return new Promise((resolve) => {
+    exec(command, { cwd, env, timeout: 60000, maxBuffer: 4 * 1024 * 1024, shell: '/bin/bash' }, (error, stdout, stderr) => {
+      resolve({
+        stdout: String(stdout || ''),
+        stderr: String(stderr || (error && error.message) || ''),
+        exit_code: error ? (typeof error.code === 'number' ? error.code : 1) : 0,
+      });
+    });
+  });
+}
+
 function parseArgs(argv) {
   const a = { business: null, model: 'atris:fast', memberId: null, memberSlug: null, calendar: false, message: null };
   for (let i = 0; i < argv.length; i++) {
@@ -215,6 +236,7 @@ async function runAtris2Turn(opts = {}) {
     idleMs = 180000,
     connectTimeoutMs = 60000,
     signal = null,
+    localCwd = null,
   } = opts;
   const t0 = Date.now();
   const out = { ok: false, text: '', engine: null, tools_run: 0, cli_ops: [], unsupported: [], error: null, duration_ms: 0 };
@@ -299,7 +321,9 @@ async function runAtris2Turn(opts = {}) {
                   out = { status: 'error', error: 'unsupported op or unsafe path' };
                   unsupported.push(`file_op:${op}`);
                 } else {
-                  const term = await runTerminal(base, token, cmd, business);
+                  const term = localCwd
+                    ? await runLocalTerminal(cmd, localCwd)
+                    : await runTerminal(base, token, cmd, business);
                   const ok = term.exit_code === 0;
                   out = ok
                     ? { status: 'ok', stdout: String(term.stdout || '').slice(0, 12000) }
@@ -316,7 +340,9 @@ async function runAtris2Turn(opts = {}) {
                   out = { status: 'error', error: `unsupported atris cli op: ${op || '?'}` };
                   unsupported.push(`cli_op:${op || '?'}`);
                 } else {
-                  const term = await runTerminal(base, token, cmd, business);
+                  const term = localCwd
+                    ? await runLocalTerminal(cmd, localCwd)
+                    : await runTerminal(base, token, cmd, business);
                   out = atrisCliResult(cmd, term);
                   cliOps.push(op || '?');
                 }
@@ -325,7 +351,7 @@ async function runAtris2Turn(opts = {}) {
                 unsupported.push(`tool:${name || '?'}`);
               }
               await postJson(`${base}/atris2/turn/tool-result`, token,
-                { call_id: ev.call_id || ev.id, result: out }, 30000);
+                { call_id: ev.call_id || ev.id, result_base64: encodeToolResult(out) }, 30000);
               resetIdle();
             }).catch((e) => reject(e));
           } else if (et === 'result') {
@@ -441,4 +467,5 @@ module.exports = {
   fileOpCommand,
   atrisCliCommand,
   atrisCliResult,
+  runLocalTerminal,
 };

package/commands/pulse.js

@@ -49,7 +49,7 @@ Options:
   --json                 Print machine-readable output
   --no-claude            Do not spawn Claude-backed mission work
   --no-verify            Skip verifier command
-  --verify "<cmd>"       Verifier for changed-work ticks (default: npm test)
+  --verify "<cmd>"       Verifier for changed-work ticks (default: npm test if package.json exists, else none)
   --cadence "<cron>"     Cron cadence for install
   --days <n>             Auto-expire installed heartbeat after n days
   --hours <n>            Auto-expire installed heartbeat after n hours
@@ -76,8 +76,6 @@ function emit(obj, asJson) {
   return obj;
 }
 
-const STATE_HOME = path.join(os.homedir(), '.atris', 'overnight', 'atris-cli-self-improve');
-
 // --- engine: run one mission-run-due tick via the real CLI ---
 
 function runMissionEngine(root, { noClaude = false, timeoutMs = 600000 } = {}) {
@@ -166,25 +164,51 @@ function gitSnapshot(root) {
   return { head, dirty: new Set(gitChangedFiles(root)) };
 }
 
-function runVerify(root, verifyCmd, timeoutMs = 600000) {
+// 30 min: the full suite takes ~8 min alone but 15+ under concurrent mission
+// load; a 10-min cap turned green suites into false verify FAILs (tick 159).
+function runVerify(root, verifyCmd, timeoutMs = 1800000) {
   if (!verifyCmd) return { passed: null, cmd: null };
+  const { envWithNodeDir } = require('../lib/spawn-env');
   const r = spawnSync(verifyCmd, {
     cwd: root,
     shell: true,
     encoding: 'utf8',
     timeout: timeoutMs,
-    env: { ...process.env, ATRIS_SKIP_UPDATE_CHECK: '1', ATRIS_AGENT_PROOF_ONLY: '0' },
+    env: envWithNodeDir({ ...process.env, ATRIS_SKIP_UPDATE_CHECK: '1', ATRIS_AGENT_PROOF_ONLY: '0' }),
   });
   return { passed: r.status === 0, cmd: verifyCmd, status: r.status };
 }
 
+function refreshOrbPolicyLessons(root, ingestion, now = new Date()) {
+  if (!ingestion || ingestion.historical_failures < 1) return null;
+  const {
+    loadHistory,
+    mineProofPolicy,
+    writePolicyLessons,
+    syncLessonsMd,
+  } = require('../lib/policy-lessons');
+  const mined = mineProofPolicy(loadHistory(root), {
+    now,
+    orbWindowDays: ingestion.summary && ingestion.summary.days,
+  });
+  const statePath = writePolicyLessons(root, mined);
+  const lessonsMd = syncLessonsMd(root, mined);
+  const orbLesson = mined.lessons.find((lesson) => lesson.id === 'orb-job-failures') || null;
+  return {
+    status: orbLesson ? orbLesson.status : null,
+    state_path: statePath,
+    lessons_md_path: lessonsMd.path,
+    lessons_md_written: lessonsMd.written,
+  };
+}
+
 // --- atris pulse tick ---
 
 function tickCommand(args, root = process.cwd()) {
   const asJson = wantsJson(args);
   const noClaude = hasFlag(args, '--no-claude');
   const noVerify = hasFlag(args, '--no-verify');
-  const verifyCmd = noVerify ? null : readFlag(args, '--verify', 'npm test');
+  const verifyCmd = noVerify ? null : readFlag(args, '--verify', pulse.defaultVerifyCmd(root));
   const startedAt = Date.now();
 
   // Detect a previous tick that died mid-run before we take the lock.
@@ -199,6 +223,20 @@ function tickCommand(args, root = process.cwd()) {
   }
 
   const tickIndex = pulse.nextTickIndex(root);
+  let orbIngestion = {
+    summary: null,
+    improvement_candidates: [],
+    scorecards_written: 0,
+    historical_failures: 0,
+  };
+  let orbPolicy = null;
+  let orbIngestError = null;
+  try {
+    orbIngestion = pulse.ingestOrbScorecard(root);
+    orbPolicy = refreshOrbPolicyLessons(root, orbIngestion);
+  } catch (error) {
+    orbIngestError = String(error && error.message ? error.message : error);
+  }
   const signalExitCode = { SIGINT: 130, SIGTERM: 143 };
   let interrupted = false;
   const finishInterrupted = (signal) => {
@@ -225,18 +263,31 @@ function tickCommand(args, root = process.cwd()) {
     tickIndex,
     phase: 'started',
     prevTickStale: priorStale.stale,
+    orbScorecard: orbIngestion.summary,
+    improvementCandidates: orbIngestion.improvement_candidates,
+    orbIngestError,
   }));
 
   let engine;
   let verify = { passed: null, cmd: verifyCmd };
   try {
-    const before = gitSnapshot(root);
+    // Non-git workspaces made producedWork permanently false (empty git delta),
+    // so every tick scored 0 no matter what the engine wrote. Fall back to a
+    // filesystem snapshot when git is absent.
+    const isRepo = fs.existsSync(path.join(root, '.git'));
+    const before = isRepo ? gitSnapshot(root) : pulse.fsSnapshot(root);
     engine = runEngine(root, { noClaude, autopilotFallback: !hasFlag(args, '--no-autopilot') });
-    const after = gitSnapshot(root);
+    const after = isRepo ? gitSnapshot(root) : pulse.fsSnapshot(root);
     // This tick's ACTUAL contribution: files it newly dirtied, or a new commit.
     // Pre-existing dirt is excluded so reward isn't re-credited every tick.
-    const changedFiles = [...after.dirty].filter((f) => !before.dirty.has(f));
-    const committed = Boolean(before.head && after.head && before.head !== after.head);
+    let changedFiles;
+    let committed = false;
+    if (isRepo) {
+      changedFiles = [...after.dirty].filter((f) => !before.dirty.has(f));
+      committed = Boolean(before.head && after.head && before.head !== after.head);
+    } else {
+      changedFiles = pulse.diffFsSnapshots(before, after);
+    }
     const producedWork = committed || changedFiles.length > 0;
 
     // Verify only matters when the tick produced work; a no-op tick skips it.
@@ -270,6 +321,9 @@ function tickCommand(args, root = process.cwd()) {
       elapsedMs,
       prevTickStale: priorStale.stale,
       reward,
+      orbScorecard: orbIngestion.summary,
+      improvementCandidates: orbIngestion.improvement_candidates,
+      orbIngestError,
     });
     pulse.appendPulseReceipt(root, receipt);
 
@@ -283,10 +337,33 @@ function tickCommand(args, root = process.cwd()) {
         changedFiles,
         elapsedMs,
         model: process.env.ATRIS_RUNNER_MODEL || process.env.ATRIS_CLAUDE_MODEL || DEFAULT_CLAUDE_RUNNER_MODEL,
+        orbScorecard: orbIngestion.summary,
+        improvementCandidates: orbIngestion.improvement_candidates,
       }));
       scorecardWritten = true;
     }
 
+    // Closure sweep rides the heartbeat: escalate overdue open loops once a
+    // day without a human invoking atris close sweep. Never fails the tick.
+    let closure = null;
+    try {
+      const { scanState, sweepState } = require('./close');
+      const scanned = scanState(root);
+      const swept = sweepState(root);
+      closure = {
+        open: swept.open,
+        overdue: swept.overdue.length,
+        escalated_today: swept.escalated_today,
+        scanned: {
+          opened: scanned.opened.length,
+          auto_closed: scanned.auto_closed.length,
+        },
+      };
+    } catch { /* closure ledger optional */ }
+
+    // Rewrite the live vitals page so an open browser tab shows this tick.
+    try { require('../lib/improve-vitals-html').writeVitalsHtml(root); } catch { /* page is a bonus */ }
+
     const out = {
       ok: true,
       action: 'pulse_tick',
@@ -300,11 +377,23 @@ function tickCommand(args, root = process.cwd()) {
       prev_tick_stale: priorStale.stale,
       elapsed_ms: elapsedMs,
       receipts_path: pulse.pulseReceiptsPath(root),
+      orb_scorecard: orbIngestion.summary,
+      orb_improvement_candidates: orbIngestion.improvement_candidates,
+      orb_scorecards_written: orbIngestion.scorecards_written,
+      orb_policy_lesson: orbPolicy,
     };
+    if (orbIngestError) out.orb_ingest_error = orbIngestError;
+    if (closure) out.closure = closure;
     if (!asJson) {
       const ghost = priorStale.stale ? ` (recovered ghost tick #${priorStale.tick_index || '?'})` : '';
       const r = reward > 0 ? `+${reward}` : String(reward);
       process.stdout.write(`pulse tick #${tickIndex}: ${what} - verify ${verify.passed === null ? 'n/a' : verify.passed ? 'pass' : 'FAIL'} - reward ${r}${ghost}\n`);
+      if (orbIngestion.summary && orbIngestion.summary.fail > 0) {
+        process.stdout.write(`orb: ${orbIngestion.summary.fail} failed job${orbIngestion.summary.fail === 1 ? '' : 's'} in the ${orbIngestion.summary.days}-day window; ${orbIngestion.scorecards_written} new improvement candidate${orbIngestion.scorecards_written === 1 ? '' : 's'} recorded.\n`);
+      }
+      if (closure && closure.overdue > 0) {
+        process.stdout.write(`closure: ${closure.overdue} open loop${closure.overdue === 1 ? '' : 's'} overdue, run: atris close sweep\n`);
+      }
     }
     return emit(out, asJson);
   } catch (err) {
@@ -318,8 +407,21 @@ function tickCommand(args, root = process.cwd()) {
       what: `tick crashed: ${err && err.message ? err.message : String(err)}`,
       elapsedMs: Date.now() - startedAt,
       reward: -1,
+      orbScorecard: orbIngestion.summary,
+      improvementCandidates: orbIngestion.improvement_candidates,
+      orbIngestError,
     }));
-    const out = { ok: false, action: 'pulse_tick', tick_index: tickIndex, error: err && err.message ? err.message : String(err) };
+    const out = {
+      ok: false,
+      action: 'pulse_tick',
+      tick_index: tickIndex,
+      error: err && err.message ? err.message : String(err),
+      orb_scorecard: orbIngestion.summary,
+      orb_improvement_candidates: orbIngestion.improvement_candidates,
+      orb_scorecards_written: orbIngestion.scorecards_written,
+      orb_policy_lesson: orbPolicy,
+    };
+    if (orbIngestError) out.orb_ingest_error = orbIngestError;
     if (!asJson) process.stdout.write(`pulse tick #${tickIndex} crashed: ${out.error}\n`);
     return emit(out, asJson);
   } finally {
@@ -331,34 +433,89 @@ function tickCommand(args, root = process.cwd()) {
 
 // --- atris pulse status ---
 
-function cronInstalled(marker = pulse.PULSE_MARKER) {
+function crontabHasActiveMarker(crontab, markers = pulse.PULSE_MARKER) {
+  const markerList = (Array.isArray(markers) ? markers : [markers]).filter(Boolean);
+  return String(crontab || '')
+    .split('\n')
+    .map((line) => line.trim())
+    .filter((line) => line && !line.startsWith('#'))
+    .some((line) => markerList.some((marker) => line.includes(marker)));
+}
+
+function cronInstalled(markers = pulse.PULSE_MARKER, commandSpawn = spawnSync) {
   try {
-    const r = spawnSync('crontab', ['-l'], { encoding: 'utf8', timeout: 10000 });
+    const r = commandSpawn('crontab', ['-l'], { encoding: 'utf8', timeout: 10000 });
     if (r.status !== 0) return false;
-    return String(r.stdout || '').includes(marker);
+    return crontabHasActiveMarker(r.stdout, markers);
   } catch {
     return false;
   }
 }
 
-function statusCommand(args, root = process.cwd()) {
+function pulseExpiryBreadcrumbPath(root) {
+  return path.join(root, '.atris', 'state', 'pulse-expired.json');
+}
+
+function readPulseExpiryBreadcrumb(root) {
+  try {
+    const raw = fs.readFileSync(pulseExpiryBreadcrumbPath(root), 'utf8').trim();
+    const candidates = [];
+    if (raw) candidates.push(raw, ...raw.split('\n').reverse());
+    for (const candidate of candidates) {
+      try {
+        const parsed = JSON.parse(candidate);
+        if (parsed
+          && typeof parsed.expired_at === 'string'
+          && typeof parsed.state_home === 'string'
+          && typeof parsed.renew_command === 'string') {
+          return parsed;
+        }
+      } catch {}
+    }
+  } catch {}
+  return null;
+}
+
+function clearPulseExpiryBreadcrumb(root) {
+  const file = pulseExpiryBreadcrumbPath(root);
+  try {
+    if (!fs.existsSync(file)) return false;
+    fs.rmSync(file, { force: true });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function statusCommand(args, root = process.cwd(), options = {}) {
   const asJson = wantsJson(args);
+  const slot = pulse.resolvePulseSlot(root, options.homeDir ? { homeDir: options.homeDir } : {});
   const receipts = pulse.readPulseReceipts(root);
   const summary = pulse.summarizePulse(receipts);
-  const installed = cronInstalled();
+  const installed = cronInstalled(slot.markers, options.spawnSync || spawnSync);
+  const expiryBreadcrumb = installed ? null : readPulseExpiryBreadcrumb(root);
+  const writeOutput = options.writeOutput || ((text) => process.stdout.write(text));
   const out = {
     ok: true,
     action: 'pulse_status',
     cron_installed: installed,
+    expiry_breadcrumb: expiryBreadcrumb,
+    state_home: slot.activeStateHome,
+    marker: slot.activeMarker,
+    install_state_home: slot.stateHome,
+    install_marker: slot.marker,
+    legacy_slot: slot.legacyMatches,
     ...summary,
   };
   if (!asJson) {
-    process.stdout.write([
-      `pulse: ${installed ? 'cron INSTALLED' : 'cron NOT installed (run: atris pulse install)'}`,
+    writeOutput([
+      `pulse: ${installed ? 'cron installed' : 'cron not installed (run: atris pulse install)'}`,
+      expiryBreadcrumb ? `heartbeat expired on ${expiryBreadcrumb.expired_at}; renew with: ${expiryBreadcrumb.renew_command}` : '',
+      `state home: ${slot.activeStateHome} marker: ${slot.activeMarker}`,
       `ticks: ${summary.total_ticks} | reward: ${summary.reward_sum} | verify pass/fail: ${summary.verify_pass}/${summary.verify_fail}`,
-      `last tick: ${summary.last_tick_ts || 'never'} (verify ${summary.last_verify_passed === null ? 'n/a' : summary.last_verify_passed ? 'pass' : 'FAIL'})`,
-      summary.stale.stale ? `⚠ STALE: ${summary.stale.reason}${summary.stale.tick_index ? ` (ghost tick #${summary.stale.tick_index})` : ''}` : 'liveness: fresh',
-      summary.orphan_ticks.length ? `⚠ orphan (crashed) ticks: ${summary.orphan_ticks.join(', ')}` : '',
+      `last tick: ${summary.last_tick_ts || 'never'} (verify ${summary.last_verify_passed === null ? 'n/a' : summary.last_verify_passed ? 'pass' : 'fail'})`,
+      summary.stale.stale ? `stale: ${summary.stale.reason}${summary.stale.tick_index ? ` (ghost tick #${summary.stale.tick_index})` : ''}` : 'liveness: fresh',
+      summary.orphan_ticks.length ? `orphan (crashed) ticks: ${summary.orphan_ticks.join(', ')}` : '',
     ].filter(Boolean).join('\n') + '\n');
   }
   return emit(out, asJson);
@@ -366,9 +523,9 @@ function statusCommand(args, root = process.cwd()) {
 
 // --- atris pulse install / uninstall ---
 
-function resolveAtrisBin() {
+function resolveAtrisBin(commandSpawn = spawnSync) {
   // Prefer a globally linked `atris`; fall back to this checkout's bin.
-  const which = spawnSync('which', ['atris'], { encoding: 'utf8', timeout: 8000 });
+  const which = commandSpawn('which', ['atris'], { encoding: 'utf8', timeout: 8000 });
   if (which.status === 0 && which.stdout.trim()) return which.stdout.trim();
   return `${process.execPath} ${path.join(__dirname, '..', 'bin', 'atris.js')}`;
 }
@@ -376,17 +533,17 @@ function resolveAtrisBin() {
 // The dirs holding the binaries the engine spawns by bare name (claude, node,
 // git, atris). Baked into the cron script's PATH so a minimal cron environment
 // can still find them. Missing tools just contribute nothing.
-function resolveEngineBinDirs(extraBins = []) {
+function resolveEngineBinDirs(extraBins = [], commandSpawn = spawnSync) {
   const dirs = new Set([path.dirname(process.execPath)]); // node
   for (const tool of ['ax', 'claude', 'git', 'atris']) {
-    const r = spawnSync('which', [tool], { encoding: 'utf8', timeout: 8000 });
+    const r = commandSpawn('which', [tool], { encoding: 'utf8', timeout: 8000 });
     if (r.status === 0 && r.stdout.trim()) dirs.add(path.dirname(r.stdout.trim()));
   }
   for (const bin of [process.env.ATRIS_RUNNER_BIN, process.env.ATRIS_CLAUDE_BIN, ...extraBins]) {
     const configured = String(bin || '').trim();
     if (configured && configured.includes(path.sep)) dirs.add(path.dirname(configured));
     if (configured && !configured.includes(path.sep)) {
-      const r = spawnSync('which', [configured], { encoding: 'utf8', timeout: 8000 });
+      const r = commandSpawn('which', [configured], { encoding: 'utf8', timeout: 8000 });
       if (r.status === 0 && r.stdout.trim()) dirs.add(path.dirname(r.stdout.trim()));
     }
   }
@@ -394,8 +551,19 @@ function resolveEngineBinDirs(extraBins = []) {
   return Array.from(dirs);
 }
 
-function installCommand(args, root = process.cwd()) {
+function stripMarkedCrontabLines(crontab, markers) {
+  const markerList = Array.isArray(markers) ? markers : [markers];
+  return String(crontab || '')
+    .split('\n')
+    .filter((line) => line && !markerList.some((marker) => marker && line.includes(marker)))
+    .join('\n');
+}
+
+function installCommand(args, root = process.cwd(), options = {}) {
   const asJson = wantsJson(args);
+  const commandSpawn = options.spawnSync || spawnSync;
+  const writeOutput = options.writeOutput || ((text) => process.stdout.write(text));
+  const slot = pulse.resolvePulseSlot(root, options.homeDir ? { homeDir: options.homeDir } : {});
   const cadenceInput = readFlag(args, '--cadence', pulse.DEFAULT_CADENCE_CRON);
   let cron;
   try {
@@ -429,23 +597,24 @@ function installCommand(args, root = process.cwd()) {
     if (!asJson) process.stdout.write(`pulse install failed: ${out.detail}\n`);
     return emit(out, asJson);
   }
-  const verifyCmd = readFlag(args, '--verify', 'npm test');
+  const verifyCmd = readFlag(args, '--verify', pulse.defaultVerifyCmd(root));
   const model = readFlag(args, '--model', process.env.ATRIS_RUNNER_MODEL || process.env.ATRIS_CLAUDE_MODEL || DEFAULT_CLAUDE_RUNNER_MODEL);
   const runnerProfile = readFlag(args, '--runner-profile', process.env.ATRIS_RUNNER_PROFILE || '');
   const runnerBin = readFlag(args, '--runner-bin', process.env.ATRIS_RUNNER_BIN || process.env.ATRIS_CLAUDE_BIN || '');
   const runnerCommandTemplate = readFlag(args, '--runner-template', process.env.ATRIS_RUNNER_COMMAND_TEMPLATE || process.env.ATRIS_CLAUDE_COMMAND_TEMPLATE || '');
   const deadlineEpoch = Math.floor(Date.now() / 1000) + expiry.seconds;
 
-  fs.mkdirSync(STATE_HOME, { recursive: true });
-  const scriptPath = path.join(STATE_HOME, 'tick.sh');
+  fs.mkdirSync(slot.stateHome, { recursive: true });
+  const scriptPath = path.join(slot.stateHome, 'tick.sh');
   // Resolve the real bin dirs the engine spawns by bare name, so cron's minimal
   // PATH doesn't silently break the worker spawn (claude lives in ~/.local/bin).
-  const pathDirs = resolveEngineBinDirs([runnerBin]);
+  const pathDirs = resolveEngineBinDirs([runnerBin], commandSpawn);
   const script = pulse.buildTickScript({
     root,
-    atrisBin: resolveAtrisBin(),
-    stateHome: STATE_HOME,
+    atrisBin: resolveAtrisBin(commandSpawn),
+    stateHome: slot.stateHome,
     deadlineEpoch,
+    marker: slot.marker,
     model,
     runnerProfile,
     runnerBin,
@@ -455,18 +624,23 @@ function installCommand(args, root = process.cwd()) {
   });
   fs.writeFileSync(scriptPath, script, { mode: 0o755 });
 
-  const line = pulse.buildCrontabLine({ cron, scriptPath });
-  // Append our line to the existing crontab (idempotent: strip any prior marker first).
-  const existing = spawnSync('crontab', ['-l'], { encoding: 'utf8', timeout: 10000 });
+  const line = pulse.buildCrontabLine({ cron, scriptPath, marker: slot.marker });
+  // Append our line to the existing crontab. Strip this repo's new marker and,
+  // when the legacy tick.sh belongs to this root, strip the old single-slot marker too.
+  const existing = commandSpawn('crontab', ['-l'], { encoding: 'utf8', timeout: 10000 });
   const prior = existing.status === 0 ? String(existing.stdout || '') : '';
-  const cleaned = prior.split('\n').filter((l) => l && !l.includes(pulse.PULSE_MARKER)).join('\n');
+  const cleaned = stripMarkedCrontabLines(prior, slot.markers);
   const next = `${cleaned ? cleaned + '\n' : ''}${line}\n`;
-  const apply = spawnSync('crontab', ['-'], { input: next, encoding: 'utf8', timeout: 10000 });
+  const apply = commandSpawn('crontab', ['-'], { input: next, encoding: 'utf8', timeout: 10000 });
+  const expiryBreadcrumbCleared = apply.status === 0 && clearPulseExpiryBreadcrumb(root);
 
   const out = {
     ok: apply.status === 0,
     action: 'pulse_install',
     script_path: scriptPath,
+    state_home: slot.stateHome,
+    marker: slot.marker,
+    legacy_migrated: slot.legacyMatches,
     crontab_line: line,
     cadence: cron,
     cadence_input: cadenceInput,
@@ -477,34 +651,50 @@ function installCommand(args, root = process.cwd()) {
     runner_profile: runnerProfile || null,
     runner_bin: runnerBin || null,
     runner_template_configured: Boolean(runnerCommandTemplate),
+    expiry_breadcrumb_cleared: expiryBreadcrumbCleared,
   };
   if (!asJson) {
     if (apply.status === 0) {
-      process.stdout.write([
+      writeOutput([
         `pulse installed. heartbeat fires '${cron}' against ${root}.`,
         `script: ${scriptPath}`,
         `auto-expires in ${expiry.hours ? `${expiry.hours} hours` : `${expiry.days} days`}. stop early: atris pulse uninstall`,
       ].join('\n') + '\n');
     } else {
-      process.stdout.write(`pulse install failed to write crontab: ${apply.stderr || apply.status}\nscript written to ${scriptPath}; add this line to your crontab manually:\n${line}\n`);
+      writeOutput(`pulse install failed to write crontab: ${apply.stderr || apply.status}\nscript written to ${scriptPath}; add this line to your crontab manually:\n${line}\n`);
     }
   }
   return emit(out, asJson);
 }
 
-function uninstallCommand(args) {
+function uninstallCommand(args, root = process.cwd()) {
   const asJson = wantsJson(args);
+  const slot = pulse.resolvePulseSlot(root);
   const existing = spawnSync('crontab', ['-l'], { encoding: 'utf8', timeout: 10000 });
   if (existing.status !== 0) {
-    const out = { ok: true, action: 'pulse_uninstall', removed: false, reason: 'no_crontab' };
+    const out = {
+      ok: true,
+      action: 'pulse_uninstall',
+      removed: false,
+      reason: 'no_crontab',
+      state_home: slot.activeStateHome,
+      marker: slot.activeMarker,
+    };
     if (!asJson) process.stdout.write('pulse: no crontab to clean.\n');
     return emit(out, asJson);
   }
   const prior = String(existing.stdout || '');
-  const had = prior.includes(pulse.PULSE_MARKER);
-  const cleaned = prior.split('\n').filter((l) => l && !l.includes(pulse.PULSE_MARKER)).join('\n');
+  const had = slot.markers.some((marker) => prior.includes(marker));
+  const cleaned = stripMarkedCrontabLines(prior, slot.markers);
   const apply = spawnSync('crontab', ['-'], { input: cleaned ? cleaned + '\n' : '', encoding: 'utf8', timeout: 10000 });
-  const out = { ok: apply.status === 0, action: 'pulse_uninstall', removed: had };
+  const out = {
+    ok: apply.status === 0,
+    action: 'pulse_uninstall',
+    removed: had,
+    state_home: slot.activeStateHome,
+    marker: slot.activeMarker,
+    legacy_slot: slot.legacyMatches,
+  };
   if (!asJson) process.stdout.write(had ? 'pulse uninstalled (crontab line removed).\n' : 'pulse: no heartbeat line found.\n');
   return emit(out, asJson);
 }
@@ -553,6 +743,10 @@ module.exports = {
   tickCommand,
   statusCommand,
   cronInstalled,
+  crontabHasActiveMarker,
+  pulseExpiryBreadcrumbPath,
+  readPulseExpiryBreadcrumb,
+  clearPulseExpiryBreadcrumb,
   installCommand,
   uninstallCommand,
   runCommand,
@@ -561,5 +755,6 @@ module.exports = {
   runEngine,
   gitChangedFiles,
   runVerify,
-  STATE_HOME,
+  refreshOrbPolicyLessons,
+  stripMarkedCrontabLines,
 };