atris 3.74.4 → 3.74.6

package/commands/ninety-nine.js

@@ -0,0 +1,288 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { randomUUID } = require('node:crypto');
+const { argsWantHelp } = require('../lib/noninteractive');
+const { getAtrisDir, loadCredentials } = require('../utils/auth');
+const { stateHome } = require('../lib/state-home');
+const { validateSync, checkpointKey, syncLines } = require('../lib/ninety-nine-sync');
+const {
+  validLength,
+  parseSessionLog,
+  foldSessions,
+  runningSession,
+  startRecord,
+  endRecord,
+  automaticEndRecord,
+  pauseRecord,
+  resumeRecord,
+  sessionStatus,
+  sessionsToday,
+  healthToday,
+  healthSummary,
+} = require('../lib/ninety-nine');
+
+function usage() {
+  return [
+    'usage: atris 99 focus <25|50|90>',
+    '       atris 99 meditate <10|20|30>',
+    '       atris 99 stop [note words]',
+    '       atris 99 pause',
+    '       atris 99 resume',
+    '       atris 99 status [--json]',
+    '       atris 99 today [--json]',
+    '       atris 99 sync [--dry-run]',
+    '',
+    'sync is off without a sync block in ~/.atris/99/config.json (ATRIS_99_CONFIG overrides it).',
+    'personal: {"sync":{"target":"personal","app_slug":"project-99"}}',
+    'workspace: {"sync":{"target":"workspace","business":"your-business","workspace":"optional-id"}}',
+    'both targets merge in both directions; workspace reads atris/99/sessions.*.jsonl and legacy sessions.jsonl.',
+    'workspace writes only sessions.<device>.jsonl; its stable device id lives in the local sync state.',
+    'personal uses your user login and defaults to app_slug project-99; its records api must be deployed first.',
+    'dry-run reads cloud records and shows missing lines without saving logs or the sync cursor.',
+  ].join('\n');
+}
+
+function readJson(file, fallback) {
+  const text = readLog(file);
+  if (!text) return fallback;
+  try { return JSON.parse(text); } catch { throw new Error('check the 99 config or sync-state json'); }
+}
+
+function saveSyncState(file, state) {
+  const temporary = `${file}.${randomUUID()}.tmp`;
+  try {
+    fs.writeFileSync(temporary, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 });
+    fs.renameSync(temporary, file);
+  } finally {
+    fs.rmSync(temporary, { force: true });
+  }
+}
+
+async function syncNinetyNine(args, { log, logPath, configPath, statePath, request, credentials = loadCredentials }) {
+  if (args.length > 1 || (args.length === 1 && args[0] !== '--dry-run')) {
+    log('usage: atris 99 sync [--dry-run]');
+    return 2;
+  }
+  let lock;
+  let lockPath;
+  let stateLock;
+  let stateLockPath;
+  try {
+    const dir = path.join(stateHome(), '.atris', '99');
+    const config = readJson(configPath || process.env.ATRIS_99_CONFIG || path.join(dir, 'config.json'), {});
+    if (!config?.sync) {
+      log('sync is off (local only)');
+      return 0;
+    }
+    validateSync(config.sync);
+    const creds = await credentials();
+    if (!creds?.token) throw new Error('sync needs your signed-in user login; run atris login');
+    const dryRun = args.includes('--dry-run');
+    const file = logPath || process.env.ATRIS_99_LOG || path.join(dir, 'sessions.jsonl');
+    const stateFile = statePath || path.join(dir, 'sync-state.json');
+    if (!dryRun) {
+      for (const folder of new Set([path.dirname(file), path.dirname(stateFile)])) {
+        fs.mkdirSync(folder, { recursive: true, mode: 0o700 });
+      }
+      // Serialize cursor updates, even if callers use different local logs.
+      stateLockPath = `${stateFile}.lock`;
+      stateLock = fs.openSync(stateLockPath, 'wx', 0o600);
+      lockPath = `${file}.lock`;
+      lock = fs.openSync(lockPath, 'wx', 0o600);
+    }
+    let text = readLog(file);
+    const records = parseSessionLog(text);
+    const state = readJson(stateFile, { v: 1, targets: {} });
+    if (state?.v !== 1 || !state.targets || typeof state.targets !== 'object' || Array.isArray(state.targets)) {
+      throw new Error('check the 99 sync-state json');
+    }
+    const key = checkpointKey(config.sync, creds);
+    const checkpoint = state.targets[key] || {};
+    if ((checkpoint.known !== undefined && (!Array.isArray(checkpoint.known) || !checkpoint.known.every((item) => typeof item === 'string')))
+      || (checkpoint.since != null && !Number.isFinite(Date.parse(checkpoint.since)))) {
+      throw new Error('check the 99 sync-state json');
+    }
+    if (config.sync.target === 'workspace' && state.device_id === undefined) {
+      state.device_id = randomUUID();
+      // Save the identity before uploading, even if the reply or later log save fails.
+      // The state lock keeps simultaneous local runs on the same device file.
+      if (!dryRun) saveSyncState(stateFile, state);
+    }
+    const result = await syncLines({ records, sync: config.sync, checkpoint, deviceId: state.device_id, credentials: creds, dryRun, request });
+    if (dryRun) {
+      log(`would send ${result.send.length} lines and pull ${result.pull.length} lines (${config.sync.target})`);
+      for (const record of result.send) log(`send: ${JSON.stringify(record)}`);
+      for (const record of result.pull) log(`pull: ${JSON.stringify(record)}`);
+    } else {
+      for (const record of result.pull) text = appendRecord(file, text, record);
+      state.targets[key] = result.checkpoint;
+      saveSyncState(stateFile, state);
+      log(`sent ${result.send.length} lines and pulled ${result.pull.length} lines (${config.sync.target})`);
+    }
+    return 0;
+  } catch (error) {
+    const message = error.code === 'EEXIST' ? 'session sync is busy; try again'
+      : error.code ? 'check the sync file paths and permissions' : error.message;
+    log(`could not sync: ${String(message).replace(/\s+/g, ' ')}`);
+    return 1;
+  } finally {
+    for (const [handle, file] of [[lock, lockPath], [stateLock, stateLockPath]]) {
+      if (handle !== undefined) {
+        fs.closeSync(handle);
+        fs.unlinkSync(file);
+      }
+    }
+  }
+}
+
+function readLog(logPath) {
+  try { return fs.readFileSync(logPath, 'utf8'); } catch (error) {
+    if (error.code === 'ENOENT') return '';
+    throw error;
+  }
+}
+
+function appendRecord(logPath, previousText, record) {
+  // A valid last record may lack a newline. Preserve every existing byte.
+  const separator = previousText && !previousText.endsWith('\n') ? '\n' : '';
+  const line = `${separator}${JSON.stringify(record)}\n`;
+  fs.appendFileSync(logPath, line, { mode: 0o600 });
+  return previousText + line;
+}
+
+function ninetyNineAtris(args = process.argv.slice(3), {
+  log = console.log,
+  now = () => new Date(),
+  logPath,
+  configPath,
+  statePath,
+  request,
+  credentials,
+} = {}) {
+  const [action, ...rest] = args;
+  // Words after stop belong to its note, including the word "help".
+  if ((action !== 'stop' && argsWantHelp(args)) || (action === 'stop' && ['--help', '-h'].includes(rest[0]))) {
+    log(usage());
+    return 0;
+  }
+  if (action === 'sync') return syncNinetyNine(rest, { log, logPath, configPath, statePath, request, credentials });
+  const json = rest.includes('--json');
+  if (action === 'focus' || action === 'meditate') {
+    if (rest.length !== 1 || !validLength(action, Number(rest[0])) || String(Number(rest[0])) !== rest[0]) {
+      log(action === 'focus' ? 'choose focus 25, 50, or 90 minutes' : 'choose meditate 10, 20, or 30 minutes');
+      return 2;
+    }
+  } else if (action === 'status' || action === 'today') {
+    if (rest.length > 1 || (rest.length === 1 && !json)) {
+      log(`usage: atris 99 ${action} [--json]`);
+      return 2;
+    }
+  } else if (action === 'pause' || action === 'resume') {
+    if (rest.length) {
+      log(`usage: atris 99 ${action}`);
+      return 2;
+    }
+  } else if (action !== 'stop') {
+    log(usage());
+    return 2;
+  }
+
+  let lock;
+  let lockPath;
+  try {
+    const override = logPath || process.env.ATRIS_99_LOG;
+    const file = override || path.join(getAtrisDir(), '99', 'sessions.jsonl');
+    const dir = path.dirname(file);
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    // An override may live in a shared folder. Only tighten our own folder.
+    if (!override) fs.chmodSync(dir, 0o700);
+    lockPath = `${file}.lock`;
+    try { lock = fs.openSync(lockPath, 'wx', 0o600); } catch (error) {
+      if (error.code === 'EEXIST') throw new Error('session log is busy; try again');
+      throw error;
+    }
+    let text = readLog(file);
+    const records = parseSessionLog(text);
+    let sessions = foldSessions(records);
+    const time = now();
+    let active = runningSession(sessions, time);
+    const stopTarget = action === 'stop'
+      ? active || sessions.findLast((session) => automaticEndRecord(session, time)?.status === 'done')
+      : null;
+
+    for (const session of sessions) {
+      const end = automaticEndRecord(session, time);
+      if (end && session !== stopTarget) {
+        text = appendRecord(file, text, end);
+        records.push(end);
+      }
+    }
+
+    if (action === 'stop') {
+      if (!stopTarget) {
+        log('nothing running');
+        return 1;
+      }
+      const end = endRecord(stopTarget, time, rest.join(' '));
+      appendRecord(file, text, end);
+      log(`${stopTarget.kind} ${end.status}: ${end.status === 'done' ? stopTarget.planned_min : 0} finished minutes`);
+      return 0;
+    }
+
+    sessions = foldSessions(records);
+    active = runningSession(sessions, time);
+    if (action === 'focus' || action === 'meditate') {
+      if (active) {
+        log('a session is already running; use atris 99 stop first');
+        return 1;
+      }
+      appendRecord(file, text, startRecord(action, Number(rest[0]), time, randomUUID()));
+      log(`${action} started for ${rest[0]} minutes`);
+    } else if (action === 'pause' || action === 'resume') {
+      let record;
+      try {
+        record = action === 'pause' ? pauseRecord(active, time) : resumeRecord(active, time);
+      } catch (error) {
+        log(error.message);
+        return 1;
+      }
+      appendRecord(file, text, record);
+      log(`${active.kind} ${action === 'pause' ? 'paused' : 'resumed'}`);
+    } else if (action === 'status') {
+      const result = sessionStatus(active, time);
+      if (json) log(JSON.stringify(result));
+      else if (!active) log('nothing running');
+      else {
+        const seconds = result.running.remaining_seconds;
+        log(`${active.kind}: ${Math.floor(seconds / 60)}:${String(seconds % 60).padStart(2, '0')} left${active.status === 'paused' ? ' (paused)' : ''}`);
+      }
+    } else {
+      const result = sessionsToday(sessions, time);
+      const health = healthToday(records, time);
+      if (health) result.health_day = health;
+      if (json) log(JSON.stringify(result));
+      else {
+        for (const session of result.sessions) {
+          log(`${session.kind} ${session.planned_min} minutes: ${session.status}`);
+        }
+        log(`${result.finished_minutes} finished minutes today`);
+        log(`Today: ${result.counts.focus} focus, ${result.counts.meditate} meditate, ${result.finished_minutes} min`);
+        if (health) log(healthSummary(health));
+      }
+    }
+    return 0;
+  } catch (error) {
+    const message = error.code ? 'check the file path and its permissions' : error.message;
+    log(`could not use the session log: ${String(message).replace(/\s+/g, ' ')}`);
+    return 1;
+  } finally {
+    if (lock !== undefined) {
+      fs.closeSync(lock);
+      fs.unlinkSync(lockPath);
+    }
+  }
+}
+
+module.exports = { ninetyNineAtris };

package/commands/one-lap.js

@@ -242,6 +242,18 @@ function lapModelPins(executor, validators = []) {
   };
 }
 
+// The roster pins, then a caller's overrides: a time cap for the build wins
+// over the roster's, and a caller's house rules ride at the end of the
+// builder's brief (atris idea tick sends both).
+function lapFlightPins(executor, validators = [], options = {}) {
+  const pins = lapModelPins(executor, validators);
+  const cap = Math.floor(Number(options.maxSeconds));
+  if (Number.isFinite(cap) && cap > 0) pins.maxSeconds = cap;
+  const brief = String(options.brief || '').trim();
+  if (brief) pins.brief = brief;
+  return pins;
+}
+
 function taskById(runCli, taskId) {
   const result = runCli(['task', 'show', taskId, '--json']);
   if (!result || result.status !== 0) return null;
@@ -426,10 +438,16 @@ async function runOneLap(ask, options = {}) {
   const asJson = options.asJson === true;
   const runCli = options.ownCli || ((args, cwd = root) => ownCli(root, args, cwd));
   const progress = options.progress || ((line) => process.stderr.write(`${line}\n`));
+  // A caller that drives laps itself (atris idea tick) reads the result object
+  // instead of parsing printed text, and can keep the lap quiet.
+  const report = (result) => {
+    if (typeof options.onResult === 'function') options.onResult(result);
+    if (options.quiet !== true) emit(result, asJson);
+  };
   const text = String(ask || '').replace(/\s+/g, ' ').trim();
   if (!text) {
     const result = { schema: 'atris.one_lap.v1', ok: false, status: 'stuck', reason: 'a request is required', next_action: 'atris "<request>"' };
-    emit(result, asJson);
+    report(result);
     return 2;
   }
 
@@ -453,7 +471,7 @@ async function runOneLap(ask, options = {}) {
         : oneLapRetryCommand(text, options),
     });
     result.resumed = true;
-    emit(result, asJson);
+    report(result);
     return 0;
   }
 
@@ -467,7 +485,7 @@ async function runOneLap(ask, options = {}) {
       nextAction: wishAnswerCommand(existing.wish),
     });
     result.resumed = true;
-    emit(result, asJson);
+    report(result);
     return 0;
   }
 
@@ -483,7 +501,7 @@ async function runOneLap(ask, options = {}) {
       reason: 'the lap verifier is frozen after intake and cannot be replaced on retry',
       next_action: oneLapRetryCommand(text, { engine: options.engine || '', verifier: existingVerifier }),
     };
-    emit(result, asJson);
+    report(result);
     return 2;
   }
   if (task && ['review', 'done'].includes(String(task.status || ''))) {
@@ -500,7 +518,7 @@ async function runOneLap(ask, options = {}) {
         reason: 'the matching task is in Review without a passing matching one-lap receipt',
         next_action: `atris task show ${shellQuote(task.display_id)}`,
       };
-      emit(result, asJson);
+      report(result);
       return 1;
     }
     const result = {
@@ -528,7 +546,7 @@ async function runOneLap(ask, options = {}) {
       master_changed: false,
       ...(prior && prior.receipt && prior.receipt.result ? { result: prior.receipt.result } : {}),
     };
-    emit(result, asJson);
+    report(result);
     return 0;
   }
   if (task && String(task.status || '') === 'claimed') {
@@ -543,7 +561,7 @@ async function runOneLap(ask, options = {}) {
         nextAction: `atris task show ${shellQuote(task.display_id)}`,
       });
       result.resumed = true;
-      emit(result, asJson);
+      report(result);
       return 0;
     }
     const released = runCli(['task', 'release', task.display_id, '--as', actor, '--json']);
@@ -555,7 +573,7 @@ async function runOneLap(ask, options = {}) {
         reason: `the abandoned one-lap claim could not be released: ${detail}`,
         next_action: `atris task show ${shellQuote(task.display_id)}`,
       };
-      emit(result, asJson);
+      report(result);
       return 1;
     }
     task = taskById(runCli, task.display_id);
@@ -568,7 +586,7 @@ async function runOneLap(ask, options = {}) {
       // still has a front door: `atris wish` runs it through the gated flow.
       // Hand the new person that exact command, not unactionable prose.
       const result = { ...resultBase({ status: 'stuck', ask: text }), reason: intakeSafetyIssue, next_action: `atris wish ${shellQuote(text)}` };
-      emit(result, asJson);
+      report(result);
       return 2;
     }
   }
@@ -578,12 +596,12 @@ async function runOneLap(ask, options = {}) {
     executor = readyExecutor(root, options.engine || '');
   } catch (error) {
     const result = { ...resultBase({ status: 'stuck', ask: text }), reason: error.message, next_action: 'atris engine' };
-    emit(result, asJson);
+    report(result);
     return 2;
   }
   if (!executor) {
     const result = { ...resultBase({ status: 'stuck', ask: text }), reason: 'no ready executor engine is installed', next_action: 'atris engine' };
-    emit(result, asJson);
+    report(result);
     return 2;
   }
 
@@ -593,7 +611,7 @@ async function runOneLap(ask, options = {}) {
       const parsedIntakeVerifier = parseVerifyCommand(intakeVerifier);
       if (!parsedIntakeVerifier.ok) {
         const result = { ...resultBase({ status: 'stuck', ask: text, engine: executor, verifier: intakeVerifier }), reason: `the verifier is not safe to run (${parsedIntakeVerifier.reason})`, next_action: 'choose a local test command' };
-        emit(result, asJson);
+        report(result);
         return 2;
       }
     }
@@ -609,7 +627,7 @@ async function runOneLap(ask, options = {}) {
     if (!payload) {
       const detail = String(captured && (captured.stderr || captured.stdout) || 'wish intake failed').trim().slice(-500);
       const result = { ...resultBase({ status: 'stuck', ask: text, engine: executor }), reason: detail, next_action: oneLapRetryCommand(text, { engine: executor.id, verifier: intakeVerifier }) };
-      emit(result, asJson);
+      report(result);
       return captured && captured.status === 2 ? 2 : 1;
     }
     const durableWish = readWishes(root).find((row) => row.id === payload.wish_id);
@@ -621,12 +639,12 @@ async function runOneLap(ask, options = {}) {
         question: Array.isArray(payload.questions) ? payload.questions[0] : '',
         nextAction: wishAnswerCommand(wish),
       });
-      emit(result, asJson);
+      report(result);
       return 0;
     }
     if (payload.status !== 'delegated' || !payload.task_id || !payload.mission_id) {
       const result = { ...resultBase({ status: 'stuck', ask: text, wish, engine: executor }), reason: 'wish intake did not produce one scoped task and mission', next_action: `atris wish show ${payload.wish_id}` };
-      emit(result, asJson);
+      report(result);
       return 2;
     }
     mission = listMissions(root).find((row) => row.id === payload.mission_id) || null;
@@ -635,13 +653,13 @@ async function runOneLap(ask, options = {}) {
 
   if (!mission || !task) {
     const result = { ...resultBase({ status: 'stuck', ask: text, wish, mission, task, engine: executor }), reason: 'the scoped task or mission could not be loaded', next_action: wish && wish.id ? `atris wish show ${wish.id}` : 'atris wish list' };
-    emit(result, asJson);
+    report(result);
     return 1;
   }
   const safetyIssue = oneLapSafetyIssue(task);
   if (safetyIssue) {
     const result = { ...resultBase({ status: 'stuck', ask: text, wish, mission, task, engine: executor }), reason: safetyIssue, next_action: `atris task show ${task.display_id}` };
-    emit(result, asJson);
+    report(result);
     return 2;
   }
   let frozenVerifier = missionVerifier(mission);
@@ -652,7 +670,7 @@ async function runOneLap(ask, options = {}) {
       reason: 'the lap verifier is frozen after intake and cannot be replaced on retry',
       next_action: oneLapRetryCommand(text, { engine: options.engine || '', verifier: frozenVerifier }),
     };
-    emit(result, asJson);
+    report(result);
     return 2;
   }
   const verifier = frozenVerifier || requestedVerifier || projectVerifier(root);
@@ -666,13 +684,13 @@ async function runOneLap(ask, options = {}) {
       nextAction: oneLapRetryCommand(text, { engine: options.engine || '', verifier: '<command>' }),
     });
     result.engine = executor.id;
-    emit(result, asJson);
+    report(result);
     return 0;
   }
   const parsedVerifier = parseVerifyCommand(verifier);
   if (!parsedVerifier.ok) {
     const result = { ...resultBase({ status: 'stuck', ask: text, wish, mission, task, engine: executor, verifier }), reason: `the mission has no safe runnable verifier (${parsedVerifier.reason})`, next_action: `atris mission status ${mission.id}` };
-    emit(result, asJson);
+    report(result);
     return 2;
   }
   if (!frozenVerifier) {
@@ -685,7 +703,7 @@ async function runOneLap(ask, options = {}) {
         reason: `the verifier could not be frozen before dispatch: ${error.message}`,
         next_action: `atris mission status ${mission.id}`,
       };
-      emit(result, asJson);
+      report(result);
       return 1;
     }
   }
@@ -697,7 +715,7 @@ async function runOneLap(ask, options = {}) {
       reason: 'no distinct ready validator engine is installed',
       next_action: 'atris engine',
     };
-    emit(result, asJson);
+    report(result);
     return 2;
   }
 
@@ -711,7 +729,7 @@ async function runOneLap(ask, options = {}) {
       reviewOnly: true,
       verifierCommand: verifier,
       validatorEngines: validators.map((entry) => entry.id),
-      ...lapModelPins(executor, validators),
+      ...lapFlightPins(executor, validators, options),
       actor: mission.owner || 'mission-lead',
       installedEngines: engineRegistryView(root)
         .filter((entry) => engineReadyAt(entry))
@@ -738,7 +756,7 @@ async function runOneLap(ask, options = {}) {
     });
   } catch (error) {
     const result = { ...resultBase({ status: 'stuck', ask: text, wish, mission, task, engine: executor, verifier }), reason: error.message || String(error), next_action: `atris task show ${task.display_id}` };
-    emit(result, asJson);
+    report(result);
     return 1;
   }
 
@@ -769,7 +787,7 @@ async function runOneLap(ask, options = {}) {
       worktree: paused.worktree || null,
       next_action: paused.worktree ? `cd ${shellQuote(paused.worktree)} && atris worktree guard` : `atris task show ${shellQuote(task.display_id)}`,
     };
-    emit(result, asJson);
+    report(result);
     return 1;
   }
 
@@ -790,7 +808,7 @@ async function runOneLap(ask, options = {}) {
       worktree: ready.worktree,
       next_action: `atris mission status ${mission.id}`,
     };
-    emit(result, asJson);
+    report(result);
     return 1;
   }
 
@@ -819,7 +837,7 @@ async function runOneLap(ask, options = {}) {
     master_changed: false,
     result: flight.result,
   };
-  emit(result, asJson);
+  report(result);
   return 0;
   } finally {
     releaseAskLock(lapLock);
@@ -832,4 +850,5 @@ module.exports = {
   readyExecutor,
   readyValidators,
   lapModelPins,
+  lapFlightPins,
 };

package/commands/reel.js

@@ -14,6 +14,7 @@ const { promisify } = require('util');
 const pexec = promisify(execFile);
 const { buildReelFrame, reelFrames } = require('../lib/reel');
 const { SIZES, KINDS } = require('../lib/card');
+const { makeProfileDir, removeProfileDir, headlessArgs } = require('../lib/headless-chrome');
 
 function parseFlags(argv) {
   const flags = {}; const pos = [];
@@ -56,12 +57,16 @@ async function renderFrames(chrome, ts, spec, dir, w, h, onDone) {
       const hf = path.join(dir, `f-${pad(i)}.html`);
       const pf = path.join(dir, `f-${pad(i)}.png`);
       fs.writeFileSync(hf, html);
-      await pexec(chrome, [
-        '--headless=new', '--disable-gpu', '--hide-scrollbars', '--force-device-scale-factor=1',
-        `--window-size=${w},${h}`, '--virtual-time-budget=2200',
-        `--user-data-dir=${path.join(dir, 'ud-' + i)}`,
-        `--screenshot=${pf}`, `file://${hf}`,
-      ], { timeout: 60000 });
+      const profile = makeProfileDir('atris-reel-chrome-');
+      try {
+        await pexec(chrome, headlessArgs(profile, [
+          '--disable-gpu', '--hide-scrollbars', '--force-device-scale-factor=1',
+          `--window-size=${w},${h}`, '--virtual-time-budget=2200',
+          `--screenshot=${pf}`, `file://${hf}`,
+        ]), { timeout: 60000 });
+      } finally {
+        removeProfileDir(profile);
+      }
       onDone && onDone(++done, ts.length);
     }
   }
@@ -125,4 +130,4 @@ async function run(argv) {
   return 0;
 }
 
-module.exports = { run, findChrome, findFfmpeg };
+module.exports = { run, findChrome, findFfmpeg, renderFrames };

package/commands/sync.js

@@ -3,6 +3,7 @@ const path = require('path');
 const { stateHome } = require('../lib/state-home');
 const { ensureWikiScaffold } = require('../lib/wiki');
 const { upsertAtrisClaudeBootBlock } = require('../lib/claude-boot-block');
+const { openingLinesForRoot, upsertAgentsOpeningLines } = require('../lib/opening-lines');
 const { ensureRunIgnore } = require('../lib/gitignore');
 const {
   upsertAgentVoiceCard,
@@ -647,6 +648,13 @@ function syncAtris(options = {}) {
     updated++;
   }
 
+  const openingLines = openingLinesForRoot(process.cwd());
+  const agentsOpeningResult = upsertAgentsOpeningLines(agentsMdFile, openingLines, { dryRun });
+  if (agentsOpeningResult.action !== 'unchanged') {
+    console.log(`${dryRun ? 'Would update' : '✓ Updated'} AGENTS.md operating rules`);
+    updated++;
+  }
+
   // Update .claude/skills/atris/SKILL.md (legacy - now handled above, keeping for compatibility)
   const claudeSkillsDir = path.join(process.cwd(), '.claude', 'skills', 'atris');
   const claudeSkillFile = path.join(claudeSkillsDir, 'SKILL.md');
@@ -727,7 +735,7 @@ Key behaviors:
 
   if (fs.existsSync(rootClaudeMd)) {
     const source = fs.readFileSync(rootClaudeMd, 'utf8');
-    const result = upsertAtrisClaudeBootBlock(source);
+    const result = upsertAtrisClaudeBootBlock(source, { openingLines });
     if (result.action === 'repaired') {
       applyClaudeUpdate(result.content, 'repair atris block in CLAUDE.md (missing end marker)', 'repaired atris block in CLAUDE.md (missing end marker)');
     } else if (result.action === 'updated') {
@@ -737,7 +745,7 @@ Key behaviors:
     }
   } else {
     // Create new CLAUDE.md with just Atris block
-    const content = upsertAtrisClaudeBootBlock().content;
+    const content = upsertAtrisClaudeBootBlock('', { openingLines }).content;
     applyClaudeUpdate(content, 'create CLAUDE.md with atris block', 'created CLAUDE.md with atris block');
   }
 

package/commands/task.js

@@ -393,7 +393,8 @@ function refreshCareerXpProjection(workspaceRoot) {
   if (!workspaceRoot) return null;
   try {
     const { collectLocalXpProjection } = require('../commands/xp');
-    return collectLocalXpProjection(['--workspace', workspaceRoot]);
+    const { careerXpRoot } = require('../lib/career-xp-root');
+    return collectLocalXpProjection(['--workspace', careerXpRoot(workspaceRoot)]);
   } catch (error) {
     return {
       ok: false,
@@ -5486,7 +5487,7 @@ function cmdAcceptGroup(args) {
       proof,
     });
     if (!done.updated) { accepted.push({ id: task.id, ok: false, reason: 'not_review' }); continue; }
-    taskDb.reviewTask(db, {
+    const reviewed = taskDb.reviewTask(db, {
       id: task.id,
       actor,
       reward: 1,
@@ -5495,6 +5496,7 @@ function cmdAcceptGroup(args) {
       proof,
       careerXpEligible: isVerified, // honest: career XP ONLY for rows the human actually verified
     });
+    refreshCareerXpAfterReview(reviewed);
     stampAcceptGroupMetadata(taskDb, db, task.id, { actor, group: groupLabel, verified: isVerified, sampleVerifiedIds: [...verifiedIds] });
     accepted.push({ id: task.id, ok: true, verified: isVerified, career_xp: isVerified });
   }