atris 3.71.2 → 3.72.0

package/commands/improve.js

@@ -528,7 +528,7 @@ function collectImproveVitals(options = {}, deps = {}) {
   };
 
   // The guarantee gauge: agent landings vs human fixes over the last 14 days.
-  // Collection is bounded by --since so a huge repo only walks a fortnight.
+  // The lookback filters results while traversal can visit older ancestors.
   // No git history (not a repo, git missing) means the line is omitted silently.
   let guarantee = null;
   try {
@@ -1313,7 +1313,8 @@ function collectRevisionSignals(root, options = {}) {
 
   let raw = '';
   try {
-    raw = gitLines(root, ['log', `--since=${sinceIso}`, '--date=iso-strict', '--pretty=format:%H%x1f%P%x1f%aI%x1f%s%x1f%B%x1e']);
+    // Filter dates without pruning ancestors behind an older-dated descendant.
+    raw = gitLines(root, ['log', `--since-as-filter=${sinceIso}`, '--date=iso-strict', '--pretty=format:%H%x1f%P%x1f%aI%x1f%s%x1f%B%x1e']);
   } catch (e) {
     // a repo with no commits yet exits non-zero on `git log`; that is the
     // empty-history case, not an error. anything else (not a repo) rethrows.

package/commands/member.js

@@ -10636,11 +10636,13 @@ function memberGoFinishTask(owner, task, result, thrown = null) {
   const required = require('../lib/member-task-pick').taskCheck(task).command;
   const checked = mission.verifier_result && mission.verifier_result.passed === true
     && (!required || String(mission.verifier_result.command || '').trim() === required);
-  if (!thrown && result && result.started && ['complete', 'ready'].includes(mission.status) && checked) {
+  // The commit comes from the member's own work copy, not the main folder.
+  const workRoot = (result && result.worktree && result.worktree.path) || (mission.worktree && mission.worktree.path) || undefined;
+  const passed = !thrown && result && result.started && ['complete', 'ready'].includes(mission.status) && checked;
+  const changedNothing = passed && selfWrittenJob(task) && !runChangedSomething(taskDb, db, task, result, workRoot);
+  if (passed && !changedNothing) {
     const proof = [`[verified] ${owner} ran mission ${result.mission_id} and its check passed.`,
       receipt ? `Receipt: ${receipt}` : ''].filter(Boolean).join('\n');
-    // The commit comes from the member's own work copy, not the main folder.
-    const workRoot = (result.worktree && result.worktree.path) || (mission.worktree && mission.worktree.path) || undefined;
     const ready = taskDb.readyTask(db, { id: task.id, actor: owner, proof, workRoot });
     if (ready.ready !== false) return { id: task.id, title: task.title, outcome: 'review', receipt: receipt || null };
     // Its change already merged and the merge line closed the job.
@@ -10650,6 +10652,7 @@ function memberGoFinishTask(owner, task, result, thrown = null) {
   const lastReason = String((ticks[ticks.length - 1] || {}).reason || (ticks[ticks.length - 1] || {}).error || '');
   const outOfTime = /timeout|wall-exceeded/.test(lastReason);
   const why = thrown ? thrown.message
+    : changedNothing ? 'the run passed its check but changed nothing: no new commit, no pushed branch, no pull request'
     : outOfTime ? 'ran out of time before the work finished'
     : (result && result.error) || (result && result.started ? 'the check did not pass' : 'the run did not start');
   const reason = String(why || 'the run did not finish').split(/\r?\n/)[0].trim().slice(0, 200);
@@ -10678,6 +10681,28 @@ function memberGoFinishTask(owner, task, result, thrown = null) {
   return { id: task.id, title: task.title, outcome, reason, ...(held && forReview ? { held_for: 'review' } : {}) };
 }
 
+// A job the member wrote for itself from its mission ("next step toward:").
+function selfWrittenJob(task) {
+  return String((task && task.source_key) || '').startsWith('self-next:')
+    || (task && task.metadata && task.metadata.source === 'member mission');
+}
+
+// Did the run leave something for review? A pushed branch, a pull request,
+// or a local landing counts, and so does a commit in the work copy that
+// changes files since the job started. With no start commit on record there
+// is nothing to compare, so the run is taken at its word.
+function runChangedSomething(taskDb, db, task, result, workRoot) {
+  const landed = result && result.autoland;
+  if (landed && (landed.pushed || landed.url || landed.merged)) return true;
+  const start = String((taskDb.getTask(db, task.id) || task)?.metadata?.start_commit || '').trim();
+  if (!start) return true;
+  const cwd = workRoot || task.workspace_root || process.cwd();
+  const diff = spawnSync('git', ['diff', '--quiet', start, 'HEAD'], { cwd, encoding: 'utf8' });
+  // Exit 0 means no change. Exit 1 means the code differs; anything else
+  // could not be read, so the run is taken at its word.
+  return diff.status !== 0;
+}
+
 const MEMBER_GO_STRIKES = 3;
 
 // Failed runs on a task since its last pass, review, reopen, or a person

package/commands/mission.js

@@ -64,6 +64,7 @@ const {
   renderMorningCardRow,
 } = require('../lib/receipt-block');
 const { findCachedMissionStepReceipt } = require('../lib/receipt-evidence');
+const { captureCodeBaseline, collectCodeProvenance } = require('../lib/mission-code-provenance');
 const {
   pruneRuns,
   runsPruneLines,
@@ -1773,6 +1774,14 @@ function appendMemberLog(owner, title, fields = {}, root = process.cwd()) {
   return logPath;
 }
 
+// Shorten at a word boundary so a lesson never ends mid-word.
+function clipWords(text, max) {
+  if (text.length <= max) return text;
+  const cut = text.slice(0, max + 1);
+  const space = cut.lastIndexOf(' ');
+  return `${(space > max * 0.6 ? cut.slice(0, space) : text.slice(0, max)).replace(/[\s,;:.-]+$/, '')}...`;
+}
+
 function crystallizeMemberSkillLesson(owner, entry = {}, root = process.cwd()) {
   const dir = memberDir(owner, root);
   if (!dir) return null;
@@ -1781,38 +1790,47 @@ function crystallizeMemberSkillLesson(owner, entry = {}, root = process.cwd()) {
   const skillDir = path.join(dir, 'skills', 'auto-learned');
   fs.mkdirSync(skillDir, { recursive: true });
   const skillPath = path.join(skillDir, 'SKILL.md');
-  const existingBullets = [];
+  let lines = null;
   if (fs.existsSync(skillPath)) {
     try {
-      const raw = fs.readFileSync(skillPath, 'utf8');
-      for (const line of raw.split(/\r?\n/)) {
-        if (line.trim().startsWith('- **')) existingBullets.push(line.trim());
-      }
+      lines = fs.readFileSync(skillPath, 'utf8').split(/\r?\n/);
     } catch {}
   }
+  const bulletAt = (lines || []).map((line, i) => (line.trim().startsWith('- **') ? i : -1)).filter((i) => i >= 0);
+  const existingBullets = bulletAt.map((i) => lines[i].trim());
   const verifierText = String(entry.verifier || '').replace(/\s+/g, ' ').trim();
   const nextPushText = String(entry.next_push || '').replace(/\s+/g, ' ').trim();
   const layerLabel = String(entry.layer || 'capabilities').trim();
-  const parts = [`- **${todayName()} (${layerLabel})**: ${summary.slice(0, 140)}`];
-  if (verifierText) parts.push(`Verify: \`${verifierText.slice(0, 80)}\``);
-  if (nextPushText) parts.push(`Next push: ${nextPushText.slice(0, 120)}`);
+  const parts = [`- **${todayName()} (${layerLabel})**: ${clipWords(summary, 240)}`];
+  // A cut-off command cannot be run, so a long one is left out, never clipped.
+  if (verifierText && verifierText.length <= 300) parts.push(`Verify: \`${verifierText}\``);
+  if (nextPushText) parts.push(`Next push: ${clipWords(nextPushText, 200)}`);
   const newBullet = parts.join(' -> ');
   const deduped = [
     newBullet,
     ...existingBullets.filter((b) => !b.includes(summary.slice(0, 80))),
   ].slice(0, 5);
 
-  const content = [
-    '---',
-    'name: auto-learned',
-    `description: Verified patterns crystallized from passing runs for ${owner}. Bounded to 5 newest patterns so context never bloats.`,
-    '---',
-    '',
-    '# Auto-Learned Verified Patterns',
-    '',
-    ...deduped,
-    '',
-  ].join('\n');
+  let content;
+  if (bulletAt.length) {
+    // Keep whatever a person or reviewer wrote around the lessons; only the
+    // lesson list itself is rewritten.
+    const first = bulletAt[0];
+    const last = bulletAt[bulletAt.length - 1];
+    content = [...lines.slice(0, first), ...deduped, ...lines.slice(last + 1)].join('\n');
+  } else {
+    content = [
+      '---',
+      'name: auto-learned',
+      `description: Verified patterns crystallized from passing runs for ${owner}. Bounded to 5 newest patterns so context never bloats.`,
+      '---',
+      '',
+      '# Auto-Learned Verified Patterns',
+      '',
+      ...deduped,
+      '',
+    ].join('\n');
+  }
   fs.writeFileSync(skillPath, content, 'utf8');
   return skillPath;
 }
@@ -3198,6 +3216,7 @@ function missionFromArgs(args) {
     '--base',
     '--task',
     '--ask',
+    '--yes-lock',
     '--campaign',
     '--reserve',
     '--mission-id',
@@ -3241,6 +3260,7 @@ function missionFromArgs(args) {
   const taskIds = readRepeatedFlag(args, '--task');
   // MEMBER.md approval-required becomes an open human ask the owner must clear.
   const humanAsks = [...readRepeatedFlag(args, '--ask'), ...memberApprovalAsks(owner, process.cwd(), objective)];
+  const yesLocks = readYesLockSeal(readFlag(args, '--yes-lock', ''), wantsJson(args));
   const drive = missionDrive(readFlag(args, '--destination', ''));
   const alwaysOn = hasFlag(args, '--always-on');
   const xpTaskEnabled = hasFlag(args, '--xp-task') || hasFlag(args, '--agent-xp');
@@ -3277,6 +3297,8 @@ function missionFromArgs(args) {
     stop_condition: stopCondition,
     task_ids: taskIds,
     human_asks: humanAsks,
+    // the sealed owner steps: the guard holds what each locks until the owner says yes
+    ...(yesLocks.length ? { yes_locks: { steps: yesLocks, sealed_at: stampIso() } } : {}),
     ...(campaignId ? { campaign_id: campaignId } : {}),
     ...(drive ? { drive } : {}),
     next_action: verifier ? 'run verifier with `atris mission tick <id> --verify`' : 'define verifier or run next task',
@@ -3295,6 +3317,22 @@ function missionFromArgs(args) {
   return mission;
 }
 
+// --yes-lock '[{"step":3,"text":"...","categories":["publish"]}]': the owner
+// steps a job may not do before the owner says yes. Bad input stops the start.
+const YES_LOCK_CATEGORIES = new Set(['publish', 'tag', 'post', 'send', 'merge', 'deploy']);
+function readYesLockSeal(raw, asJson) {
+  if (!raw) return [];
+  let list;
+  try {
+    list = JSON.parse(raw);
+  } catch {
+    exitMissionError('--yes-lock takes a JSON list of {step, text, categories}', 2, asJson);
+  }
+  const ok = Array.isArray(list) && list.every(l => l && Number.isInteger(l.step) && l.step > 0 && Array.isArray(l.categories) && l.categories.length && l.categories.every(c => YES_LOCK_CATEGORIES.has(c)));
+  if (!ok) exitMissionError('--yes-lock takes a JSON list of {step, text, categories}, with categories from publish, tag, post, send, merge, deploy', 2, asJson);
+  return list.map(l => ({ step: l.step, text: String(l.text || '').slice(0, 200), categories: [...new Set(l.categories)] }));
+}
+
 function applyMissionStartPatch(mission, patch) {
   if (!patch || typeof patch !== 'object') return mission;
   const { metadata, ...rest } = patch;
@@ -4402,6 +4440,7 @@ function seedMissionRunContinuation(parent, root = process.cwd(), proof = '') {
   nextMission.next_action = `decide next mission, then run: ${nextPlan.command}`;
   nextMission.next_action_preview = nextPlan.preview;
 
+  const codeBaseline = captureCodeBaseline(root);
   ensureMemberMissionFile(nextMission.owner, root, nextMission.objective);
   const { mission: saved } = saveMission(assignMissionNumber(nextMission, root), root, 'mission_continuation_started', {
     parent_mission_id: parent.id,
@@ -4409,7 +4448,7 @@ function seedMissionRunContinuation(parent, root = process.cwd(), proof = '') {
     proof: proof || null,
   });
   if (saved.campaign_id) campaignMissions().recordCampaignMissionStarted(root, saved, 0);
-  const worktreeBaseline = captureMissionWorktreeBaseline(saved, root);
+  const worktreeBaseline = captureMissionWorktreeBaseline(saved, root, codeBaseline);
   const seededAt = stampIso();
   const { mission: updatedParent } = saveMission({
     ...parent,
@@ -4656,6 +4695,7 @@ function startMission(args, options = {}) {
     if (nodeModulesSource) mission.node_modules_source = nodeModulesSource;
     process.chdir(created.path);
   }
+  const codeBaseline = captureCodeBaseline(process.cwd());
   if (mission.xp_task_enabled) {
     const xpTask = createMissionXpTask(mission, process.cwd(), asJson);
     mission.xp_task = xpTask;
@@ -4696,7 +4736,7 @@ function startMission(args, options = {}) {
     lane: saved.lane,
     verifier: saved.verifier,
   });
-  const worktreeBaseline = captureMissionWorktreeBaseline(saved, process.cwd());
+  const worktreeBaseline = captureMissionWorktreeBaseline(saved, process.cwd(), codeBaseline);
   const nextTickCommand = `atris mission tick ${saved.id}${saved.verifier ? ' --verify' : ''}`;
   const payload = {
     ok: true,
@@ -4738,6 +4778,7 @@ function startMission(args, options = {}) {
 
 async function startMissionFromRunObjective(objective, args) {
   const asJson = wantsJson(args);
+  const codeBaseline = captureCodeBaseline(process.cwd());
   const rawObjective = String(objective || '').trim();
   const landRun = hasFlag(args, '--land');
   const dryRun = hasFlag(args, '--dry-run');
@@ -4939,7 +4980,7 @@ async function startMissionFromRunObjective(objective, args) {
     lane: saved.lane,
     verifier: saved.verifier,
   });
-  const worktreeBaseline = captureMissionWorktreeBaseline(saved, process.cwd());
+  const worktreeBaseline = captureMissionWorktreeBaseline(saved, process.cwd(), codeBaseline);
   const completedContinuationGoal = completeActiveContinuationForStartedMission(saved, process.cwd());
   const nativeGoalOptions = codexNativeGoalOptionsFromArgs(args);
   const goalSlotHandoff = hasFlag(args, '--take-goal-slot') && isCodexGoalMission(saved)
@@ -6629,6 +6670,7 @@ function writeReceipt(mission, result, root = process.cwd()) {
     tree_hash: treeHashFor(root),
     clean: codeState.clean,
     git_tree: codeState.clean ? codeState.tree : null,
+    code_provenance: collectCodeProvenance(root, loadMissionWorktreeBaseline(mission.id, root)?.code),
     mission_id: mission.id,
     objective: mission.objective,
     owner: mission.owner,
@@ -6864,7 +6906,7 @@ function missionBaselinePath(missionId, root = process.cwd()) {
 // Stored outside missions.jsonl because that log re-appends the full mission
 // record on every save. Captured after start bookkeeping so the mission's own
 // state writes land inside the baseline, not in new_since_baseline.
-function captureMissionWorktreeBaseline(mission, root = process.cwd()) {
+function captureMissionWorktreeBaseline(mission, root = process.cwd(), code = captureCodeBaseline(root)) {
   const snapshot = gitWorktreeSnapshot(root);
   if (!snapshot.available) return null;
   const baselineFile = missionBaselinePath(mission.id, root);
@@ -6880,6 +6922,7 @@ function captureMissionWorktreeBaseline(mission, root = process.cwd()) {
     dirty_count: snapshot.dirty_count,
     dirty_hash: snapshot.dirty_hash,
     paths: Array.from(paths).sort(),
+    code,
   };
   writeJson(baselineFile, baseline);
   return baseline;
@@ -9434,7 +9477,7 @@ function spawnGenericRunnerTick(mission, opts) {
     }
     let gitGuard;
     try {
-      gitGuard = prepareMissionGitGuard({ root: cwd, tags: missionProtectedTags(mission, cwd) });
+      gitGuard = prepareMissionGitGuard({ root: cwd, tags: missionProtectedTags(mission, cwd), missionId: mission.id, yesLockSeal: (mission.yes_locks && mission.yes_locks.steps) || [], stateDir: path.join(require('../lib/state-home').atrisHome(), 'state') });
     } catch (error) {
       resolve({
         ok: false,
@@ -9619,7 +9662,7 @@ function spawnClaudeTick(mission, opts) {
   return new Promise((resolve) => {
     let gitGuard;
     try {
-      gitGuard = prepareMissionGitGuard({ root: cwd, tags: missionProtectedTags(mission, cwd) });
+      gitGuard = prepareMissionGitGuard({ root: cwd, tags: missionProtectedTags(mission, cwd), missionId: mission.id, yesLockSeal: (mission.yes_locks && mission.yes_locks.steps) || [], stateDir: path.join(require('../lib/state-home').atrisHome(), 'state') });
     } catch (error) {
       resolve({
         ok: false,
@@ -10447,7 +10490,7 @@ async function executeMissionRunTicksPhase(context) {
         const prompt = buildTickPrompt(tickRuntimeMission, tickIdx, effectiveMaxTicks, frozen, pendingMissionPings(mission), cwd);
         let atris2GitGuard = null;
         try {
-          atris2GitGuard = prepareMissionGitGuard({ root: cwd, tags: missionProtectedTags(mission, cwd) });
+          atris2GitGuard = prepareMissionGitGuard({ root: cwd, tags: missionProtectedTags(mission, cwd), missionId: mission.id, yesLockSeal: (mission.yes_locks && mission.yes_locks.steps) || [], stateDir: path.join(require('../lib/state-home').atrisHome(), 'state') });
         } catch (error) {
           result = {
             ...result,
@@ -11275,12 +11318,23 @@ async function runMission(args) {
     context.error = error;
     throw error;
   } finally {
-    if (context.lock) completeMissionRunPhase(context);
+    if (context.lock) {
+      completeMissionRunPhase(context);
+      sweepMergedMemberWork(context);
+    }
   }
 
   return context.returnValue;
 }
 
+// Merged member work closes its jobs even when the team loop is down.
+function sweepMergedMemberWork(context) {
+  try {
+    const out = require('../lib/member-autoland').sweepAfterMissionRun({ cwd: context.cwd || process.cwd() });
+    if (out && out.closed > 0 && !context.asJson) console.log(out.line);
+  } catch {}
+}
+
 function tickMission(args) {
   const asJson = wantsJson(args);
   if (hasFlag(args, '--help') || hasFlag(args, '-h') || String(args[0] || '').trim() === 'help') {
@@ -12718,6 +12772,7 @@ function missionCommand(args) {
 }
 
 module.exports = {
+  crystallizeMemberSkillLesson,
   listSiblingWorkspaceMissionHints,
   missionProtectedLaneHold,
   missionCommand,

package/commands/pulse.js

@@ -53,6 +53,9 @@ Options:
   --cadence "<cron>"     Cron cadence for install
   --days <n>             Auto-expire installed heartbeat after n days
   --hours <n>            Auto-expire installed heartbeat after n hours
+  --no-keep-awake        Install without holding the Mac awake for the window (macOS)
+  --no-autopilot         install/tick: never fall back to autopilot (only campaigns and due missions)
+  --no-campaigns         tick: skip pushing campaigns (atris campaign tick)
   --model <id>           Runner model alias/id for installed heartbeat
   --runner-profile <n>   Runner profile for installed heartbeat (e.g. atris-fast)
   --runner-bin <path>    Runner binary for installed heartbeat
@@ -128,9 +131,43 @@ function runAutopilotTick(root, { timeoutMs = 600000 } = {}) {
   };
 }
 
-// The full heartbeat composition: continue a due mission, else author+pursue a
-// new goal via autopilot. This is the /loop skill's logic, encoded for OS cron.
-function runEngine(root, { noClaude = false, autopilotFallback = true, timeoutMs = 600000 } = {}) {
+// Campaigns first: one bounded push on the next campaign here that has work
+// (atris campaign tick). A campaign mission can outlast a mission tick, so it gets
+// up to 50 minutes; the campaign run lock keeps two drivers off one campaign.
+const CAMPAIGN_TICK_MS = 50 * 60 * 1000;
+function runCampaignEngine(root, { timeoutMs = CAMPAIGN_TICK_MS } = {}) {
+  const cliPath = path.join(__dirname, '..', 'bin', 'atris.js');
+  const result = spawnSync(process.execPath, [cliPath, 'campaign', 'tick', '--json'], {
+    cwd: root,
+    encoding: 'utf8',
+    timeout: timeoutMs,
+    env: { ...process.env, ATRIS_SKIP_UPDATE_CHECK: '1' },
+  });
+  let payload = null;
+  try {
+    payload = JSON.parse(result.stdout || '{}');
+  } catch {}
+  const idle = Boolean(payload && payload.picked === null);
+  return {
+    actor: 'campaign_tick',
+    ok: result.status === 0,
+    reason: idle ? 'no_campaign_work' : (payload && payload.reason) || (result.status === 0 ? 'advanced' : 'error'),
+    idle,
+    status: result.status,
+    payload,
+    stdout: String(result.stdout || '').slice(-2000),
+    stderr: String(result.stderr || '').slice(-2000),
+  };
+}
+
+// The full heartbeat composition: push a campaign that has work, else continue a
+// due mission, else author+pursue a new goal via autopilot. This is the /loop
+// skill's logic, encoded for OS cron.
+function runEngine(root, { noClaude = false, autopilotFallback = true, campaigns = true, timeoutMs = 600000 } = {}) {
+  if (campaigns && !noClaude) {
+    const campaign = runCampaignEngine(root);
+    if (!campaign.idle) return campaign;
+  }
   const mission = runMissionEngine(root, { noClaude, timeoutMs });
   if (pulse.shouldFallbackToAutopilot({ missionReason: mission.reason, autopilotFallback, noClaude })) {
     const ap = runAutopilotTick(root, { timeoutMs });
@@ -284,7 +321,7 @@ function tickCommand(args, root = process.cwd()) {
     // 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') });
+    engine = runEngine(root, { noClaude, autopilotFallback: !hasFlag(args, '--no-autopilot'), campaigns: !hasFlag(args, '--no-campaigns') });
     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.
@@ -315,7 +352,9 @@ function tickCommand(args, root = process.cwd()) {
     const changedTail = committed
       ? ' - committed'
       : (changedFiles.length ? ` - ${changedFiles.length} file(s) changed` : '');
-    const what = engine.actor === 'autopilot'
+    const what = engine.actor === 'campaign_tick'
+      ? `campaign ${(engine.payload && engine.payload.campaign && engine.payload.campaign.id) || ''} ${engine.reason}${changedTail}`.replace(/\s+/g, ' ')
+      : engine.actor === 'autopilot'
       ? `autopilot authored/advanced a goal${changedTail}`
       : engine.reason === 'no_due_mission'
         ? 'no due mission; heartbeat alive (no-op)'
@@ -677,6 +716,8 @@ function installCommand(args, root = process.cwd(), options = {}) {
     pathDirs,
     launchLabel: label,
     launchPlistPath: plistPath,
+    // Baked into every tick: a night of campaigns only, no invented goals.
+    tickFlags: ['--no-autopilot', '--no-campaigns'].filter((flag) => hasFlag(args, flag)),
   });
   fs.writeFileSync(scriptPath, script, { mode: 0o755 });
 
@@ -695,6 +736,10 @@ function installCommand(args, root = process.cwd(), options = {}) {
   const apply = commandSpawn('launchctl', ['bootstrap', `gui/${uid}`, plistPath], { encoding: 'utf8', timeout: 10000 });
   const expiryBreadcrumbCleared = apply.status === 0 && clearPulseExpiryBreadcrumb(root);
   const cadenceMapping = pulse.launchIntervalFromCadence({ cron });
+  // Tests pass their own spawnSync and never get a real caffeinate unless they ask.
+  const wantsKeepAwake = apply.status === 0 && process.platform === 'darwin' && !hasFlag(args, '--no-keep-awake')
+    && (!options.spawnSync || options.holdKeepAwake);
+  const keepAwake = wantsKeepAwake ? (options.holdKeepAwake || holdKeepAwake)(slot.stateHome, expiry.seconds) : null;
 
   const out = {
     ok: apply.status === 0,
@@ -718,6 +763,7 @@ function installCommand(args, root = process.cwd(), options = {}) {
     runner_bin: runnerBin || null,
     runner_template_configured: Boolean(runnerCommandTemplate),
     expiry_breadcrumb_cleared: expiryBreadcrumbCleared,
+    keep_awake: keepAwake,
   };
   if (!asJson) {
     if (apply.status === 0) {
@@ -728,6 +774,7 @@ function installCommand(args, root = process.cwd(), options = {}) {
         `script: ${scriptPath}`,
         cadenceMapping.fallback ? `cadence '${cron}' is not directly mappable; using 3600 seconds.` : '',
         `auto-expires in ${expiry.hours ? `${expiry.hours} hours` : `${expiry.days} days`}. stop early: atris pulse uninstall`,
+        ...(keepAwake ? [`keeps this Mac awake until then (lid open); atris pulse uninstall lets it sleep.`] : []),
       ].filter(Boolean).join('\n') + '\n');
     } else {
       writeOutput(`pulse install failed to bootstrap ${label}: ${apply.stderr || apply.status}\nplist: ${plistPath}\n`);
@@ -736,6 +783,40 @@ function installCommand(args, root = process.cwd(), options = {}) {
   return emit(out, asJson);
 }
 
+// The heartbeat only ticks while the Mac is awake. On macOS an overnight install
+// holds a no-idle-sleep assertion (caffeinate -i) for exactly the heartbeat's
+// window, so a Mac on its own power settings does not sleep through the night.
+// Closing the lid still sleeps. Uninstall lets it go. --no-keep-awake skips it.
+function keepAwakeFile(stateHome) {
+  return path.join(stateHome, 'keep-awake.pid');
+}
+
+function releaseKeepAwake(stateHome) {
+  const file = keepAwakeFile(stateHome);
+  let pid = 0;
+  try { pid = Number(fs.readFileSync(file, 'utf8').trim()); } catch { return false; }
+  fs.rmSync(file, { force: true });
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    const name = spawnSync('ps', ['-p', String(pid), '-o', 'comm='], { encoding: 'utf8', timeout: 5000 }).stdout.trim();
+    if (!/caffeinate$/.test(name)) return false;
+    process.kill(pid, 'SIGTERM');
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function holdKeepAwake(stateHome, seconds) {
+  releaseKeepAwake(stateHome);
+  const { spawn } = require('child_process');
+  const child = spawn('caffeinate', ['-i', '-t', String(Math.max(60, Math.floor(seconds)))], { detached: true, stdio: 'ignore' });
+  child.unref();
+  fs.mkdirSync(stateHome, { recursive: true });
+  fs.writeFileSync(keepAwakeFile(stateHome), `${child.pid}\n`);
+  return { pid: child.pid, seconds: Math.floor(seconds) };
+}
+
 function uninstallCommand(args, root = process.cwd(), options = {}) {
   const asJson = wantsJson(args);
   const slot = pulse.resolvePulseSlot(root, options.homeDir ? { homeDir: options.homeDir } : {});
@@ -745,6 +826,7 @@ function uninstallCommand(args, root = process.cwd(), options = {}) {
   const plistPath = path.join(homeDir, 'Library', 'LaunchAgents', `${label}.plist`);
   const uid = options.uid != null ? options.uid : process.getuid();
   commandSpawn('launchctl', ['bootout', `gui/${uid}/${label}`], { encoding: 'utf8', timeout: 10000 });
+  const keepAwakeReleased = (options.releaseKeepAwake || releaseKeepAwake)(slot.stateHome || slot.activeStateHome);
   const plistHad = fs.existsSync(plistPath);
   fs.rmSync(plistPath, { force: true });
   const existing = commandSpawn('crontab', ['-l'], { encoding: 'utf8', timeout: 10000 });
@@ -757,6 +839,7 @@ function uninstallCommand(args, root = process.cwd(), options = {}) {
     ok: apply.status === 0,
     action: 'pulse_uninstall',
     removed: plistHad || had,
+    keep_awake_released: keepAwakeReleased,
     label,
     plist_path: plistPath,
     removed_legacy_crontab: had,
@@ -818,5 +901,6 @@ module.exports = {
   pulseExpiryBreadcrumbPath,
   installCommand,
   runCommand,
+  uninstallCommand,
   refreshOrbPolicyLessons,
 };

package/commands/sync.js

@@ -1,6 +1,6 @@
 const fs = require('fs');
 const path = require('path');
-const os = require('os');
+const { stateHome } = require('../lib/state-home');
 const { ensureWikiScaffold } = require('../lib/wiki');
 const { upsertAtrisClaudeBootBlock } = require('../lib/claude-boot-block');
 const { ensureRunIgnore } = require('../lib/gitignore');
@@ -809,7 +809,7 @@ function syncSkills({ silent = false } = {}) {
   }
 
   let updated = 0;
-  const homeDir = os.homedir();
+  const homeDir = stateHome();
 
   const skillFolders = fs.readdirSync(packageSkillsDir).filter(f =>
     fs.statSync(path.join(packageSkillsDir, f)).isDirectory()