atris 3.74.5 → 3.74.7

package/bin/atris.js

@@ -1967,6 +1967,15 @@ function showWelcomeVisualization() {
     // Silent: the lineup is a hint, not a gate.
   }
 
+  // The four values settle close calls, so every new chat sees them, not
+  // only an agent that reads atris.md to the end (lib/values.js).
+  try {
+    const values = require('../lib/values').valuesForRoot(cwd);
+    values.forEach((value, index) => console.log(row(index ? '' : 'values', `${value.name.padEnd(14)}${value.gist}`)));
+  } catch {
+    // Advisory only; never blocks boot.
+  }
+
   const hasNoTasks = glance.active === 0
     && glance.review === 0
     && glance.reviewCertified === 0;

package/commands/gm.js

@@ -31,7 +31,7 @@ function showHelp() {
   console.log('       atris gm card <member> [--json]  one member\'s profile page');
   console.log('       atris gm target [--landed N] [--max-abandoned N] [--max-stuck N] [--clear]');
   console.log('       atris gm phone [--port 7777] [--send] [--new-link]  decision cards on your phone');
-  console.log('       atris gm walk [--real-copy <workspace>] [--threshold 0.8] [--no-browser]  check every stage of the phone orb');
+  console.log('       atris gm walk [--real-copy <workspace>] [--votes 3] [--no-browser]  check every stage of the phone orb');
   console.log('       atris gm --json           machine-readable state');
   console.log('       atris gm --watch [--interval 10]');
   console.log('');

package/commands/idea.js

@@ -31,6 +31,7 @@ function ideaUsage() {
     '       atris idea retry <n> [--repo <path>] [--verify "<cmd>"]',
     '       atris idea tick [--repo <path>] [--max-minutes <n>]',
     '       atris idea on|off [--repo <path>] [--dry-run]',
+    '       atris idea login|logout   (the Claude login sealed builds use)',
   ].join('\n');
 }
 
@@ -213,6 +214,35 @@ function retryIdea(ref, { repo, verify = '', json, log }) {
   return 0;
 }
 
+// One command for the login a sealed build needs: Claude's own setup-token
+// runs on the person's terminal, the token is picked off the screen (or
+// pasted when it cannot be), proven with a sign-in from a blank home, then
+// saved where only the owner can read it. Nothing is saved when it fails.
+function ideaLogin({ log = console.log, deps = {} } = {}) {
+  const login = { ...require('../lib/engine-login'), ...deps };
+  const tty = deps.isTTY !== undefined ? deps.isTTY : Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  if (!tty) {
+    log('run this in your own terminal: atris idea login');
+    return 2;
+  }
+  log('a browser window opens for Claude. approve it there; there is nothing to copy.');
+  let token = login.findToken(login.recordSetupToken().text);
+  if (!token && login.askToken) token = String(login.askToken() || '').trim();
+  if (!token) {
+    log('no login came back from claude setup-token. nothing saved.');
+    return 1;
+  }
+  const check = login.checkToken(token);
+  if (!check.ok) {
+    log(`that login did not sign in${check.detail ? `: ${check.detail}` : ''}. nothing saved.`);
+    return 1;
+  }
+  login.saveToken(token);
+  log('done. sealed builds now sign in to Claude on your subscription.');
+  log('undo: atris idea logout');
+  return 0;
+}
+
 function ideaAtris(args = process.argv.slice(3), { cwd = process.cwd(), log = console.log, keepDeps = {} } = {}) {
   const list = Array.isArray(args) ? args : [];
   if (argsWantHelp(list)) {
@@ -224,6 +254,12 @@ function ideaAtris(args = process.argv.slice(3), { cwd = process.cwd(), log = co
   const json = flags.json === true;
   const verb = words[0];
 
+  if (verb === 'login' && words.length === 1) return ideaLogin({ log, deps: keepDeps.login });
+  if (verb === 'logout' && words.length === 1) {
+    const { forgetToken } = require('../lib/engine-login');
+    log(forgetToken() ? 'sealed builds no longer have a Claude login.' : 'there was no saved login.');
+    return 0;
+  }
   if (verb === 'retry' && words.length <= 2) return retryIdea(words[1], { repo, verify: flags.verify || '', json, log });
   if ((verb === 'on' || verb === 'off') && words.length === 1) {
     return switchTimer(verb === 'on', { repo, dryRun: flags.dryRun === true, json, log, keepDeps });

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 });
   }

package/commands/xp.js

@@ -7,6 +7,9 @@ const crypto = require('crypto');
 const { spawnSync } = require('child_process');
 const { hasFlag: hasExactFlag } = require('../lib/arg-parser');
 const { treeHashFor } = require('../lib/tree-hash');
+const { careerXpRoot, careerXpLinkedRoots } = require('../lib/career-xp-root');
+const { withCareerXpLock } = require('../lib/career-xp-lock');
+const { normalizeActor, taskBuilder } = require('../lib/review-integrity');
 
 const DEFAULT_GRAPH_DAYS = 365;
 const MAX_SYNC_GRAPH_DAYS = 370;
@@ -22,15 +25,15 @@ const TASK_PROJECTION_FILE = path.join('.atris', 'state', 'tasks.projection.json
 const CODEX_STATE_FILE = path.join(os.homedir(), '.codex', 'state_5.sqlite');
 
 // Default single-workspace XP root. Local XP reads task_episodes.jsonl (written
-// by task-db at the resolved workspace root) and writes its projection beside
-// it, so the `--workspace` default must resolve the same shared root, otherwise
+// by task-db at the main checkout's workspace root) and writes its projection
+// beside it, so reads must resolve the same shared root, otherwise
 // `xp --local` from a subdir (e.g. backend/) read the wrong/empty episodes and
-// split the projection into a nested .atris. Explicit --workspace still wins;
-// the multi-root roster path (discoverCareerXpWorkspaces) is untouched. Falls
+// split the projection into a nested .atris. Explicit --workspace selects the
+// repository and nested workspace, then also resolves its shared ledger. Falls
 // back to raw cwd if the resolver can't load.
 function defaultXpWorkspace() {
   try {
-    return require('../lib/mission-root').resolveWorkspaceRoot(process.cwd());
+    return careerXpRoot(require('../lib/mission-root').resolveWorkspaceRoot(process.cwd()));
   } catch {
     return process.cwd();
   }
@@ -921,7 +924,7 @@ function receiptFromTaskEpisode(episode, treeHash) {
   );
   const proof = String(episode?.proof || '').trim();
   const reward = asNumber(episode?.career_xp?.reward ?? episode?.reward?.value, 0);
-  if (!episodeId || (!rejected && (!eligible || !proof || reward <= 0))) return null;
+  if (!episodeId || (!rejected && (!eligible || !proof || reward <= 0 || !hasIndependentXpReview(episode)))) return null;
 
   return {
     schema: 'atris.career_xp_receipt.v1',
@@ -1047,8 +1050,55 @@ function buildCareerXpProjection(receipts, workspace, integrity = {}) {
   };
 }
 
-function collectLocalXpProjectionState(args = [], { write = true } = {}) {
-  const workspace = path.resolve(readInlineFirstFlag(args, '--workspace', defaultXpWorkspace()));
+// The eligible flag records acceptance intent, not reviewer independence.
+// Apply the same actor evidence to new episodes and historical recovery.
+function hasIndependentXpReview(episode) {
+  const builder = taskBuilder(episode?.state);
+  if (!builder) return false;
+  const reviewer = normalizeActor(episode.action?.actor);
+  if (reviewer && reviewer !== builder) return true;
+  const metadata = episode.state.metadata || {};
+  const verifier = normalizeActor(metadata.certified_verified_by);
+  const reviewActors = Array.isArray(metadata.agent_review_actors) ? metadata.agent_review_actors.map(normalizeActor) : [];
+  return metadata.agent_certified === true && metadata.machine_verified === true
+    && Boolean(verifier) && verifier !== builder
+    && verifier === normalizeActor(metadata.independent_review_by)
+    && reviewActors.includes(verifier);
+}
+
+function readLinkedXpFile(filePath, options = {}) {
+  try {
+    return readJsonl(filePath, options);
+  } catch {
+    console.error(`warning: skipped unreadable linked xp file at ${filePath}`);
+    return [];
+  }
+}
+
+// Historical linked ledgers predate the shared writer. Require explicit
+// eligibility here; receipt conversion also enforces independent review.
+function recoverLinkedTaskEpisodes(workspace) {
+  return careerXpLinkedRoots(workspace).flatMap(root => readLinkedXpFile(path.join(root, TASK_EPISODES_FILE), { allowPartialTail: true }))
+    .filter(episode => episode?.state?.status === 'done' && episode?.career_xp?.eligible === true
+      && String(episode.proof || '').trim()
+      && asNumber(episode.career_xp.reward ?? episode.reward?.value) > 0
+      && hasIndependentXpReview(episode));
+}
+
+function recoverLinkedReceipts(workspace) {
+  return careerXpLinkedRoots(workspace).flatMap(root => {
+    const chain = normalizeReceiptChain(readLinkedXpFile(path.join(root, CAREER_XP_RECEIPTS_FILE)), { allowLegacyUpgrade: false });
+    return chain.integrity.status === 'verified' ? chain.receipts : [];
+  });
+}
+
+function collectLocalXpProjectionState(args = [], { write = true, resolveSharedRoot = true } = {}) {
+  const selected = path.resolve(readInlineFirstFlag(args, '--workspace', defaultXpWorkspace()));
+  const workspace = resolveSharedRoot ? careerXpRoot(selected) : selected;
+  return withCareerXpLock(workspace, () => collectLockedXpProjectionState(workspace, { write, resolveSharedRoot }));
+}
+
+function collectLockedXpProjectionState(workspace, { write, resolveSharedRoot }) {
   const episodePath = path.join(workspace, TASK_EPISODES_FILE);
   const receiptsPath = path.join(workspace, CAREER_XP_RECEIPTS_FILE);
   const projectionPath = path.join(workspace, CAREER_XP_PROJECTION_FILE);
@@ -1075,12 +1125,13 @@ function collectLocalXpProjectionState(args = [], { write = true } = {}) {
     && fileSize(episodePath) > 0
     && fileSize(receiptsPath) === 0;
   const tail = readTaskEpisodeTail(episodePath, cursorPath, { forceReset: replayFromStart });
-  const treeHash = write && tail.episodes.length ? treeHashFor(workspace) : null;
+  const recovered = resolveSharedRoot ? recoverLinkedTaskEpisodes(workspace) : [];
+  const episodes = [...tail.episodes, ...recovered];
+  const treeHash = write && episodes.length ? treeHashFor(workspace) : null;
   const seen = new Set(existingChain.receipts.map(receipt => receipt.receipt_id).filter(Boolean));
   let previousHash = existingChain.integrity.head_hash || null;
-  const newReceipts = tail.episodes
-    .map((episode) => receiptFromTaskEpisode(episode, treeHash))
-    .filter(Boolean)
+  const recoveredReceipts = resolveSharedRoot ? recoverLinkedReceipts(workspace) : [];
+  const newReceipts = [...recoveredReceipts, ...episodes.map(episode => receiptFromTaskEpisode(episode, treeHash)).filter(Boolean)]
     .filter((receipt) => {
       if (seen.has(receipt.receipt_id)) return false;
       seen.add(receipt.receipt_id);
@@ -1381,12 +1432,14 @@ function collectAllLocalXpProjection(args = []) {
   const searchRoots = defaultAllSearchRoots(args).filter(root => fs.existsSync(root));
   const explicitWorkspaces = readFlagValues(args, '--workspace');
   const discovered = searchRoots.flatMap(root => discoverCareerXpWorkspaces(root));
-  const workspaces = uniquePaths([...explicitWorkspaces, ...discovered]);
+  // Local recovery folds old checkout episodes into the durable main ledger.
+  // Canonicalize before aggregation so copies can never earn twice.
+  const workspaces = uniquePaths([...explicitWorkspaces, ...discovered].map(careerXpRoot));
   const projections = workspaces.map((workspace) => {
     try {
       return {
         workspace_root: workspace,
-        projection: collectLocalXpProjection(['--workspace', workspace]),
+        projection: collectLocalXpProjectionState(['--workspace', workspace]).projection,
       };
     } catch (error) {
       return {
@@ -1641,7 +1694,7 @@ LIMIT 25
 }
 
 function buildCareerXpSessionCapsule(args = []) {
-  const workspace = path.resolve(readInlineFirstFlag(args, '--workspace', defaultXpWorkspace()));
+  const workspace = careerXpRoot(path.resolve(readInlineFirstFlag(args, '--workspace', defaultXpWorkspace())));
   const sinceInput = readInlineFirstFlag(args, '--since', 'today');
   const untilInput = readInlineFirstFlag(args, '--until', null);
   const since = parseSessionBoundary(sinceInput, startOfToday());

package/commands/zen.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { abandonedDaysFromEnv, checkZen, sideCopyLines } = require('../lib/zen');
+const { abandonedDaysFromEnv, checkZen, nextSaveIn, sideCopyLines } = require('../lib/zen');
 const { applyZen } = require('../lib/zen-apply');
 const { workspaceZen } = require('../lib/zen-workspace');
 const { fleetFile, fleetRepos, fleetZen, printFleet } = require('../lib/zen-fleet');
@@ -57,9 +57,16 @@ function makeOut(calm) {
   return { dim, line, rake };
 }
 
-function teamLine(n) {
+// Name the three biggest places so a large count reads as "mostly agent
+// notes in atris/" rather than an unexplained total.
+function teamLine(n, places = []) {
   if (!n) return 'no unsaved team notes.';
-  return n === 1 ? '1 unsaved team note left in place.' : `${n} unsaved team notes left in place.`;
+  const head = n === 1 ? '1 unsaved team note left in place' : `${n} unsaved team notes left in place`;
+  if (!places.length) return `${head}.`;
+  const named = places.slice(0, 3).map((p) => `${p.place} ${p.count}`);
+  const rest = places.length - named.length;
+  if (rest) named.push(`and ${rest} more ${rest === 1 ? 'place' : 'places'}`);
+  return `${head}: ${named.join(', ')}.`;
 }
 
 function printYours(yours, line, dim) {
@@ -90,7 +97,9 @@ function printCheck(result, workspace) {
     console.log('  run atris zen to make it zen');
   }
   if (result.worktrees_with_work.length) {
-    for (const text of sideCopyLines(result.worktrees_with_work, abandonedDaysFromEnv())) console.log(`  ${text}`);
+    const days = abandonedDaysFromEnv();
+    const wait = nextSaveIn(result.worktrees_with_work, days);
+    for (const text of sideCopyLines(result.worktrees_with_work, days, wait)) console.log(`  ${text}`);
   }
   const held = result.worktrees_locked?.length || 0;
   if (held) {
@@ -141,7 +150,7 @@ function printApply(result, out) {
     line('  almost zen. still out of place:');
     for (const text of result.remaining) line(dim(`  - ${text}`));
   }
-  line(dim(`  ${teamLine(result.team_files)}`));
+  line(dim(`  ${teamLine(result.team_files, result.team_places)}`));
   if (result.saved.length) {
     line(dim('  nothing was thrown away. see what zen saved:   git for-each-ref refs/archive refs/heads/zen-backup'));
   }

package/lib/career-xp-lock.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { sleepSync } = require('./sleep-sync');
+
+function alive(pid) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === 'EPERM';
+  }
+}
+
+// Callers resolve the shared root before entering. Do not acquire recursively.
+function withCareerXpLock(workspace, action, { timeoutMs = 10000 } = {}) {
+  const file = path.join(workspace, '.atris', 'state', 'career_xp.lock');
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const holder = JSON.stringify({ pid: process.pid, host: os.hostname() });
+  const deadline = Date.now() + timeoutMs;
+  for (;;) {
+    let fd;
+    try {
+      fd = fs.openSync(file, 'wx');
+    } catch (error) {
+      if (error.code !== 'EEXIST') throw error;
+    }
+    if (fd !== undefined) {
+      try {
+        fs.writeFileSync(fd, holder);
+        return action();
+      } finally {
+        fs.closeSync(fd);
+        fs.unlinkSync(file);
+      }
+    }
+    try {
+      const before = fs.statSync(file);
+      let owner;
+      try { owner = JSON.parse(fs.readFileSync(file, 'utf8')); } catch {}
+      // A newly created file may still be receiving its owner record.
+      const stale = owner ? owner.host === os.hostname() && !alive(owner.pid)
+        : Date.now() - before.mtimeMs > 30000;
+      if (stale) {
+        const after = fs.statSync(file);
+        if (before.ino === after.ino && before.mtimeMs === after.mtimeMs) fs.unlinkSync(file);
+        continue;
+      }
+    } catch (error) {
+      if (error.code !== 'ENOENT') throw error;
+      continue;
+    }
+    if (Date.now() >= deadline) throw new Error('xp ledger is busy; retry');
+    sleepSync(20);
+  }
+}
+
+module.exports = { withCareerXpLock };

package/lib/career-xp-root.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const { spawnSync } = require('child_process');
+
+// Jobs keep their own checkout for verification. Their durable XP belongs in
+// the main checkout, where removing a landed job's checkout cannot erase it.
+// Preserve a nested workspace's relative path so customer workspaces stay apart.
+function careerXpRoot(workspace) {
+  const root = path.resolve(workspace);
+  try {
+    const top = spawnSync('git', ['rev-parse', '--show-toplevel'], {
+      cwd: root, encoding: 'utf8', timeout: 5000,
+    });
+    if (top.status !== 0 || !top.stdout.trim()) return root;
+    const listing = spawnSync('git', ['worktree', 'list', '--porcelain', '-z'], {
+      cwd: root, encoding: 'utf8', timeout: 5000,
+    });
+    const first = String(listing.stdout || '').split('\0')[0];
+    if (listing.status !== 0 || !first.startsWith('worktree ')) return root;
+    const main = first.slice('worktree '.length);
+    // Bare repositories and separate git storage may name the storage folder,
+    // not a checkout. Never create an XP ledger inside git's internal files.
+    if (!fs.existsSync(path.join(main, '.git'))) return root;
+    const relative = path.relative(top.stdout.trim(), root);
+    if (relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) return root;
+    return path.resolve(main, relative);
+  } catch {
+    return root;
+  }
+}
+
+// Enumerate only checkouts registered to this repository, at the same nested
+// workspace offset. Never crawl unrelated repositories or customer workspaces.
+function careerXpLinkedRoots(workspace) {
+  const root = path.resolve(workspace);
+  try {
+    // A nested workspace may exist only in a linked checkout so far.
+    let existing = root;
+    while (!fs.existsSync(existing) && path.dirname(existing) !== existing) existing = path.dirname(existing);
+    const top = spawnSync('git', ['rev-parse', '--show-toplevel'], {
+      cwd: existing, encoding: 'utf8', timeout: 5000,
+    });
+    if (top.status !== 0 || !top.stdout.trim()) return [];
+    const relative = path.relative(top.stdout.trim(), root);
+    if (relative === '..' || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) return [];
+    const listing = spawnSync('git', ['worktree', 'list', '--porcelain', '-z'], {
+      cwd: existing, encoding: 'utf8', timeout: 5000,
+    });
+    if (listing.status !== 0) return [];
+    return String(listing.stdout || '').split('\0')
+      .filter(field => field.startsWith('worktree '))
+      .map(field => path.resolve(field.slice('worktree '.length), relative))
+      .filter(candidate => candidate !== root);
+  } catch {
+    return [];
+  }
+}
+
+module.exports = { careerXpRoot, careerXpLinkedRoots };

package/lib/engine-login.js

@@ -0,0 +1,105 @@
+'use strict';
+
+// The one Claude login a sealed build may use. A sealed build hides the real
+// home, and the normal Claude login lives in the macOS keychain and refreshes
+// itself, so a build cannot borrow it. `atris idea login` runs Claude's own
+// `claude setup-token` (a long-lived login on the same subscription), keeps the
+// token in a file only the owner can read, and the sealed build passes it in.
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+const { atrisHome } = require('./state-home');
+
+const TOKEN_PATTERN = /sk-ant-oat\d{2}-[A-Za-z0-9_-]{20,}/g;
+
+function tokenFile(env = process.env) {
+  return path.join(atrisHome(env), 'secrets', 'claude-oauth-token');
+}
+
+// The token from a recording of `claude setup-token`, colors and cursor moves
+// stripped. The last one wins, since the screen may redraw.
+function findToken(text) {
+  const plain = String(text || '').replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, '').replace(/\x1b[\]P][^\x07\x1b]*(\x07|\x1b\\)/g, '');
+  const hits = plain.match(TOKEN_PATTERN);
+  return hits ? hits[hits.length - 1] : '';
+}
+
+function savedToken(env = process.env) {
+  try {
+    return fs.readFileSync(tokenFile(env), 'utf8').trim();
+  } catch {
+    return '';
+  }
+}
+
+function saveToken(token, env = process.env) {
+  const file = tokenFile(env);
+  fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+  fs.chmodSync(path.dirname(file), 0o700);
+  fs.writeFileSync(file, `${token}\n`, { mode: 0o600 });
+  fs.chmodSync(file, 0o600);
+  return file;
+}
+
+function forgetToken(env = process.env) {
+  const file = tokenFile(env);
+  if (!fs.existsSync(file)) return false;
+  fs.rmSync(file, { force: true });
+  return true;
+}
+
+// Runs `claude setup-token` on the person's own terminal while `script`
+// records what it prints, then reads the recording and deletes it.
+function recordSetupToken({ spawn = spawnSync, platform = process.platform } = {}) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'atris-login-'));
+  fs.chmodSync(dir, 0o700);
+  const log = path.join(dir, 'screen');
+  try {
+    const args = platform === 'darwin'
+      ? ['-q', log, 'claude', 'setup-token']
+      : ['-q', '-c', 'claude setup-token', log];
+    const result = spawn('script', args, { stdio: 'inherit' });
+    const text = fs.existsSync(log) ? fs.readFileSync(log, 'utf8') : '';
+    return { status: result.status, text };
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+// When the token cannot be read off the screen, the person pastes it once,
+// without it showing on screen.
+function askToken({ spawn = spawnSync } = {}) {
+  const script = 'printf "paste the token claude printed (it stays hidden): " >&2; stty -echo; read -r t; stty echo; printf "\\n" >&2; printf %s "$t"';
+  const result = spawn('sh', ['-c', script], { stdio: ['inherit', 'pipe', 'inherit'], encoding: 'utf8' });
+  return String(result.stdout || '').trim();
+}
+
+// Signs in the way a sealed build does: a blank home, no keychain, only the
+// token. Returns { ok, detail }.
+function checkToken(token, { spawn = spawnSync } = {}) {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'atris-login-check-'));
+  try {
+    const result = spawn('claude', ['-p', 'Reply with the single word ok.', '--model', 'haiku',
+      '--settings', JSON.stringify({ disableAllHooks: true }), '--strict-mcp-config', '--tools', ''], {
+      cwd: home,
+      encoding: 'utf8',
+      timeout: 120000,
+      env: {
+        PATH: process.env.PATH || '',
+        HOME: home,
+        CLAUDE_CONFIG_DIR: path.join(home, '.claude'),
+        CLAUDE_CODE_OAUTH_TOKEN: token,
+        ANTHROPIC_API_KEY: '',
+      },
+    });
+    const out = `${result.stdout || ''}${result.stderr || ''}`.trim();
+    const ok = result.status === 0 && /\bok\b/i.test(result.stdout || '');
+    return { ok, detail: ok ? '' : (out.split('\n').pop() || `exit ${result.status}`).slice(0, 200) };
+  } finally {
+    fs.rmSync(home, { recursive: true, force: true });
+  }
+}
+
+module.exports = { findToken, savedToken, saveToken, forgetToken, recordSetupToken, askToken, checkToken };

package/lib/fleet.js

@@ -1907,7 +1907,10 @@ function reviewOnlyEngineEnvironment(worktreePath, options = {}) {
     // owner policy: claude work runs on the subscription login, never API
     // billing, so the api key is stripped even when the parent env has one.
     ANTHROPIC_API_KEY: '',
-    CLAUDE_CODE_OAUTH_TOKEN: selectedSecret(['claude'], 'CLAUDE_CODE_OAUTH_TOKEN'),
+    // `atris idea login` saves this one login for sealed builds; a token
+    // already in the environment wins.
+    CLAUDE_CODE_OAUTH_TOKEN: selectedSecret(['claude'], 'CLAUDE_CODE_OAUTH_TOKEN')
+      || (selectedEngine === 'claude' ? require('./engine-login').savedToken() : ''),
     CURSOR_API_KEY: selectedSecret(['cursor'], 'CURSOR_API_KEY'),
     DEVIN_API_KEY: selectedSecret(['devin'], 'DEVIN_API_KEY'),
     XAI_API_KEY: selectedSecret(['grok'], 'XAI_API_KEY'),