atris 3.58.6 → 3.58.8

package/lib/wish-delegate.js

@@ -2,6 +2,7 @@
 
 const fs = require('fs');
 const path = require('path');
+const { BACKEND_ROOT_HINT, resolveBackendRoot } = require('../utils/backend-root');
 const { getLogPath, ensureLogDirectory, createLogFile, addInboxIdea } = require('./file-ops');
 const { resolveFunctionalOwner } = require('./functional-owner');
 const { buildMissionRoom, writeMissionRoomReceipt } = require('./mission-room');
@@ -55,7 +56,6 @@ const {
 } = require('./wish-audit');
 
 const METRIC_OPS = { '>=': '--gte', '<=': '--lte', '==': '--eq', '>': '--gt', '<': '--lt' };
-const METRIC_VERIFY_ROOT = '/Users/keshavrao/arena/atrisos-backend';
 const DAY_MS = 24 * 60 * 60 * 1000;
 const HOUR_MS = 60 * 60 * 1000;
 const IMPLICIT_ANSWER_STALE_MS = HOUR_MS;
@@ -105,8 +105,11 @@ function parseMetricExpression(text) {
 
 // Wire to backend/scripts/metric_verify.py: exits 0 when the metric meets
 // target and prints a JSON line with value + proof_uri.
-function metricVerifierCommand(parsed) {
-  return `cd ${METRIC_VERIFY_ROOT} && venv/bin/python backend/scripts/metric_verify.py ${parsed.metric} ${parsed.flag} ${parsed.target}`;
+function metricVerifierCommand(parsed, workspace) {
+  const backend = resolveBackendRoot(workspace);
+  if (!backend) throw new Error(BACKEND_ROOT_HINT);
+  const quoted = `'${backend.replace(/'/g, `'\\''`)}'`;
+  return `cd ${quoted} && venv/bin/python backend/scripts/metric_verify.py ${parsed.metric} ${parsed.flag} ${parsed.target}`;
 }
 
 const MISSION_TERMINAL_STATUSES = new Set(['complete', 'stopped']);
@@ -489,7 +492,9 @@ function scorecardText(value) {
 }
 
 function readWishReviewRewardRows(root = process.cwd()) {
-  const file = path.resolve(root, '..', 'atrisos-backend', '.atris', 'state', 'scorecards.jsonl');
+  const backend = resolveBackendRoot(root);
+  if (!backend) return [];
+  const file = path.join(backend, '.atris', 'state', 'scorecards.jsonl');
   return readJsonLines(file).filter((row) => {
     const haystack = `${scorecardText(row.source)} ${scorecardText(row.feedback)}`;
     return /wish_review/i.test(haystack);
@@ -514,6 +519,7 @@ function reviewLine(review) {
 
 function printRewards(root = process.cwd()) {
   const reviews = readWishEvents(root).filter((event) => event && event.kind === 'review');
+  if (!resolveBackendRoot(root)) console.error(BACKEND_ROOT_HINT);
   const rewardRows = readWishReviewRewardRows(root);
   console.log(`reviews count: ${reviews.length}`);
   console.log(`avg score: ${averageReviewScore(reviews)}`);
@@ -749,7 +755,7 @@ function startWishDelegation(wish, audit, root, options = {}) {
   const suppliedVerifyHasCommand = !!(suppliedVerifyPlan && suppliedVerifyPlan.command);
   const userVerifyProvided = options.userVerifyProvided === true || options.verifyPlanExplicit === true;
   let verifyPlan = metricPlan
-    ? { command: metricVerifierCommand(metricPlan), outcome: `metric ${metricPlan.expression} is met`, status: 'metric' }
+    ? { command: metricVerifierCommand(metricPlan, root), outcome: `metric ${metricPlan.expression} is met`, status: 'metric' }
     : (suppliedVerifyPlan || deriveVerifyPlan(taskText));
   if (!metricPlan && frontendWish && designContext.auditCommand && !userVerifyProvided && !suppliedVerifyHasCommand && !(verifyPlan && verifyPlan.command)) {
     verifyPlan = designVerifyPlan(designContext);
@@ -1529,6 +1535,10 @@ function runCapturedWish(text, root = process.cwd(), options = {}) {
   const asJson = !!options.asJson;
   const noMission = !!options.noMission;
   const builderMode = String(options.asMode || '').trim() === 'builder';
+  if (options.metric?.ok && !resolveBackendRoot(root)) {
+    console.error(BACKEND_ROOT_HINT);
+    return 2;
+  }
   let engineOverride = '';
   try {
     engineOverride = validateEngineOverride(options.engineOverride, root);
@@ -1617,6 +1627,10 @@ function runAgainWish(positionals, root = process.cwd(), options = {}) {
 function applyAnswer(wish, answer, root, options = {}) {
   const asJson = !!options.asJson;
   const noMission = !!options.noMission;
+  if (wish.metric && !resolveBackendRoot(root)) {
+    console.error(BACKEND_ROOT_HINT);
+    return 2;
+  }
   let engineOverride = '';
   try {
     engineOverride = validateEngineOverride(options.engineOverride, root);

package/mcp/atris-mcp/index.mjs

@@ -0,0 +1,227 @@
+#!/usr/bin/env node
+// atris mcp, a stdio Model Context Protocol server exposing the design API.
+// Tools: design_extract, design_check, design_search.
+// Auth resolves the same way as the CLI: ATRIS_API_KEY, then
+// the logged-in atris token, then ~/.atris/design-api-key.
+
+import { readFileSync, realpathSync } from 'node:fs';
+import { createInterface } from 'node:readline';
+import { fileURLToPath } from 'node:url';
+import designApi from '../../lib/design-api.js';
+
+const { resolveDesignKey, designRequest, pollDesignJob, billingOf } = designApi;
+
+export const TOOLS = [
+  {
+    name: 'design_extract',
+    description: 'extract a site\'s design system (colors, typography, layout, voice) as json. costs 10 credits, 2 on a cache hit.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        url: { type: 'string', description: 'site url to extract, e.g. https://stripe.com' },
+      },
+      required: ['url'],
+    },
+  },
+  {
+    name: 'design_check',
+    description: 'score how closely a page follows a reference brand. costs 20 credits.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        source_url: { type: 'string', description: 'page being checked' },
+        reference_url: { type: 'string', description: 'brand url to check against' },
+      },
+      required: ['source_url', 'reference_url'],
+    },
+  },
+  {
+    name: 'design_search',
+    description: 'search brands already extracted by atris design. costs 1 credit.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'plain words, e.g. "dark developer tools brand"' },
+        limit: { type: 'number', description: 'max results' },
+      },
+      required: ['query'],
+    },
+  },
+];
+
+function terminal(job) {
+  const s = String((job && job.status) || '').toLowerCase();
+  return s === 'completed' || s === 'failed' || s === 'error' || s === 'succeeded';
+}
+
+function withBilling(data) {
+  const bill = billingOf(data);
+  return {
+    ...(data && typeof data === 'object' ? data : { result: data }),
+    credits_charged: bill.credits,
+    balance_remaining_usd: bill.balanceUsd,
+  };
+}
+
+function ok(data) {
+  return { content: [{ type: 'text', text: JSON.stringify(withBilling(data), null, 2) }] };
+}
+
+function fail(message) {
+  return { content: [{ type: 'text', text: message }], isError: true };
+}
+
+async function callApi(pathname, options, key) {
+  const res = await designRequest(pathname, { ...options, key });
+  if (!res.ok) throw new Error(`http ${res.status}: ${res.error || 'request failed'}`);
+  if (!res.data || typeof res.data !== 'object') {
+    throw new Error('the design api returned an empty response');
+  }
+  return res.data;
+}
+
+async function runJob(first, pollPath, key) {
+  if (!first || typeof first !== 'object') {
+    throw new Error('the design api returned an empty response');
+  }
+  let job = first;
+  if (!terminal(job) && !job.id) {
+    throw new Error('the design api returned no job id');
+  }
+  if (!terminal(job) && job.id) {
+    let failures = 0;
+    const polled = await pollDesignJob(async () => {
+      try {
+        const out = await callApi(pollPath, {}, key);
+        failures = 0;
+        return out;
+      } catch (error) {
+        failures += 1;
+        if (failures >= 3) return { status: 'failed', id: job.id, error: (error && error.message) || String(error) };
+        return { status: 'polling' };
+      }
+    });
+    if (polled.timedOut) {
+      throw new Error(`still running after 3 minutes. job id: ${job.id}, poll: ${pollPath}`);
+    }
+    job = polled.job || job;
+  }
+  if (job.status !== 'completed') {
+    throw new Error(`job ${job.id || 'unknown'} did not finish: ${job.error || job.status || 'unknown'} (poll: ${pollPath})`);
+  }
+  return job;
+}
+
+export async function handleTool(name, args = {}, key) {
+  if (name === 'design_extract') {
+    const url = String(args.url || '').trim();
+    if (!url) return fail('design_extract needs a url');
+    const first = await callApi('/design/extractions', { method: 'POST', body: { url } }, key);
+    return ok(await runJob(first, `/design/extractions/${first.id}`, key));
+  }
+  if (name === 'design_check') {
+    const source = String(args.source_url || '').trim();
+    const reference = String(args.reference_url || '').trim();
+    if (!source || !reference) return fail('design_check needs source_url and reference_url');
+    const first = await callApi('/design/adherence', {
+      method: 'POST',
+      body: { source_url: source, reference_url: reference },
+    }, key);
+    return ok(await runJob(first, `/design/adherence/${first.id}`, key));
+  }
+  if (name === 'design_search') {
+    const query = String(args.query || '').trim();
+    if (!query) return fail('design_search needs a query');
+    const body = { query };
+    if (Number.isInteger(args.limit) && args.limit > 0) body.limit = args.limit;
+    return ok(await callApi('/design/search', { method: 'POST', body }, key));
+  }
+  return fail(`unknown tool: ${name}`);
+}
+
+async function serveStdio() {
+  const { name, version } = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8'));
+  const knownVersions = new Set(['2024-11-05', '2025-03-26', '2025-06-18', '2025-11-25']);
+  const send = (message, onWritten) => process.stdout.write(`${JSON.stringify({ jsonrpc: '2.0', ...message })}\n`, onWritten);
+  const input = createInterface({ input: process.stdin, crlfDelay: Infinity });
+  const inFlight = new Set();
+  const pendingById = new Map();
+
+  for await (const line of input) {
+    if (!line.trim()) continue;
+    let request;
+    try {
+      request = JSON.parse(line);
+    } catch {
+      send({ id: null, error: { code: -32700, message: 'parse error' } });
+      continue;
+    }
+    if (!request || typeof request !== 'object' || Array.isArray(request)
+      || request.jsonrpc !== '2.0' || typeof request.method !== 'string') {
+      send({ id: request?.id ?? null, error: { code: -32600, message: 'invalid request' } });
+      continue;
+    }
+    if (request.method === 'notifications/cancelled') {
+      const pending = pendingById.get(request.params?.requestId);
+      if (pending) pending.cancelled = true;
+      continue;
+    }
+    if (!Object.hasOwn(request, 'id')) continue;
+
+    const id = request.id;
+    let result;
+    if (request.method === 'initialize') {
+      result = {
+        protocolVersion: knownVersions.has(request.params?.protocolVersion)
+          ? request.params.protocolVersion : '2025-06-18',
+        capabilities: { tools: {} },
+        serverInfo: { name, version },
+      };
+    } else if (request.method === 'ping') {
+      result = {};
+    } else if (request.method === 'tools/list') {
+      result = { tools: TOOLS };
+    } else if (request.method === 'tools/call') {
+      const pending = { cancelled: false };
+      const work = (async () => {
+        try {
+          const key = resolveDesignKey();
+          result = key
+            ? await handleTool(request.params?.name, request.params?.arguments || {}, key)
+            : fail('no api key found. set ATRIS_API_KEY or run: atris login (or save a key in ~/.atris/design-api-key)');
+        } catch (error) {
+          result = fail(`design call failed: ${(error && error.message) || error}`);
+        }
+        if (!pending.cancelled) {
+          await new Promise((resolve, reject) => {
+            send({ id, result }, (error) => (error ? reject(error) : resolve()));
+          });
+        }
+      })();
+      inFlight.add(work);
+      pendingById.set(id, pending);
+      const done = () => {
+        inFlight.delete(work);
+        if (pendingById.get(id) === pending) pendingById.delete(id);
+      };
+      work.then(done, (error) => {
+        done();
+        process.stderr.write(`mcp response write failed: ${(error && error.message) || error}\n`);
+        process.exitCode = 1;
+      });
+      continue;
+    } else {
+      send({ id, error: { code: -32601, message: 'method not found' } });
+      continue;
+    }
+    send({ id, result });
+  }
+  await Promise.allSettled(inFlight);
+}
+
+// Auto-start only when run directly (`atris mcp`, `npx atris-mcp`,
+// node index.mjs); realpathSync resolves the npm bin symlink.
+const invokedPath = process.argv[1] ? realpathSync(process.argv[1]) : '';
+if (invokedPath && invokedPath === fileURLToPath(import.meta.url)) {
+  await serveStdio();
+}

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "atris",
-  "version": "3.58.6",
+  "version": "3.58.8",
   "description": "you say what you want in plain words. atris builds it, checks it, and shows you proof.",
   "main": "bin/atris.js",
   "bin": {
     "atris": "bin/atris",
-    "ax": "ax"
+    "ax": "ax",
+    "atris-mcp": "mcp/atris-mcp/index.mjs"
   },
   "files": [
     "ax",
@@ -19,6 +20,7 @@
     "scripts/det/",
     "utils/",
     "lib/",
+    "mcp/",
     "templates/",
     "README.md",
     "AGENTS.md",

package/scripts/det/det.js

@@ -84,7 +84,7 @@ function catalogText() {
   );
   const gitRows = GIT_SCRIPTS.map((g) => `  ${g.name.padEnd(15)} ${g.usage}\n    ${g.ask}`);
   return (
-    'deterministic task scripts — run: node det.js <script> <mode> < input\n\n' +
+    'deterministic task scripts: run node det.js <script> <mode> < input\n\n' +
     rows.join('\n\n') +
     '\n\ngit-facing (read the repo, run the script directly; not via det.js):\n\n' +
     gitRows.join('\n\n') +
@@ -121,7 +121,7 @@ async function main() {
   }
   const git = GIT_SCRIPTS.find((g) => g.name === script);
   if (git) {
-    process.stdout.write(`${git.name} reads the repo, not stdin — run it directly:\n  ${git.usage}\n`);
+    process.stdout.write(`${git.name} reads the repo, not stdin; run it directly:\n  ${git.usage}\n`);
     return;
   }
   const entry = CATALOG[script];

package/scripts/det/pr-description.js

@@ -78,7 +78,7 @@ function areaBullets(files) {
     if (counts.A) parts.push(`${counts.A} added`);
     if (counts.M) parts.push(`${counts.M} changed`);
     if (counts.D) parts.push(`${counts.D} removed`);
-    bullets.push(`- **${area}** — ${parts.join(', ')} (+${added}/-${deleted})`);
+    bullets.push(`- **${area}**: ${parts.join(', ')} (+${added}/-${deleted})`);
   }
   return bullets;
 }
@@ -108,7 +108,7 @@ function build(input) {
   const commits = (input && input.commits) || [];
   const files = (input && input.files) || [];
   if (!commits.length && !files.length) {
-    return { error: 'no commits or files vs base — is the branch ahead of it?' };
+    return { error: 'no commits or files vs base: is the branch ahead of it?' };
   }
   const totals = files.reduce(
     (a, f) => ({ added: a.added + (f.added || 0), deleted: a.deleted + (f.deleted || 0) }),

package/scripts/det/test.js

@@ -211,7 +211,7 @@ check(
     { path: 'scripts/det/b.js', status: 'M', added: 2, deleted: 1 },
     { path: 'test/x.test.js', status: 'A', added: 5, deleted: 0 },
   ]),
-  ['- **scripts** — 1 added, 1 changed (+12/-1)', '- **test** — 1 added (+5/-0)']
+  ['- **scripts**: 1 added, 1 changed (+12/-1)', '- **test**: 1 added (+5/-0)']
 );
 // test plan lists touched test files, then a check per non-test area
 check(
@@ -267,7 +267,7 @@ check('det.git.json', JSON.parse(catalogJson()).git['commit-msg'].usage.includes
 // stdin catalog stays separate from the git list (routing must not mix them)
 check('det.git.notRoutable', CATALOG['commit-msg'], undefined);
 
-console.log(`ok — ${passed} checks passed`);
+console.log(`ok: ${passed} checks passed`);
 
 // hunk-filter: keeps only matching hunks, drops non-matching files entirely
 {

package/scripts/det/ytnotes

@@ -21,11 +21,14 @@ mkdir -p "$WORK"
 cd "$WORK"
 
 # Printed metadata and a written English VTT are a hit even when yt-dlp exits 429.
+# A leaked WARNING|ERROR print line is not the video id.
 # Manual English is --write-subs. Auto English is often en-orig / en-US / en-GB.
-# Teach reads the same list on disk. Empty --print still keeps a VTT written
-# in this run (id from the watch / shorts / embed / live / e / nocookie embed URL
-# or the new filename). A copied #t= timestamp is stripped so leftover
-# yt_<id> files still match.
+# Teach parses leftover yt_<id>.clean.txt stamps as cues.
+# Empty --print still keeps a VTT written in this run (id from the watch /
+# shorts / embed / live / e / nocookie embed URL or the new filename). A copied
+# #t= timestamp is stripped so leftover yt_<id> files still match. When VTT is
+# gone, leftover yt_<id>.clean.txt from a prior notes run is still a keep.
+# Another video's leftover clean.txt is not invent-keep.
 existing=""
 for name in yt_*.en.vtt yt_*.en-orig.vtt yt_*.en-US.vtt yt_*.en-GB.vtt; do
   [ -e "$name" ] || continue
@@ -38,8 +41,33 @@ META=$(yt-dlp --no-update --quiet --no-warnings --skip-download \
   -o "yt_%(id)s" \
   --print "%(id)s|%(title)s|%(channel)s|%(duration_string)s" \
   "$URL" 2>/dev/null) || true
-ID="${META%%|*}"
-INFO="${META#*|}"
+# Skip WARNING/ERROR/INFO print leaks and NA/None sentinels. Keep the last
+# id|title line so notes stay on yt_<id>.md and keep can find them after a
+# later error. Same sentinel bar as watch/search looksLikeFlatVideoId.
+ID=""
+INFO=""
+while IFS= read -r line || [ -n "$line" ]; do
+  trimmed="${line#"${line%%[![:space:]]*}"}"
+  case "$trimmed" in
+    WARNING*|ERROR*|INFO*|warning*|error*|info*) continue ;;
+  esac
+  case "$trimmed" in
+    *'|'*)
+      cand="${trimmed%%|*}"
+      folded=$(printf '%s' "$cand" | tr '[:upper:]' '[:lower:]')
+      case "$folded" in
+        ''|na|none) continue ;;
+      esac
+      case "$cand" in
+        *[!A-Za-z0-9_-]*) continue ;;
+      esac
+      ID="$cand"
+      INFO="${trimmed#*|}"
+      ;;
+  esac
+done <<EOF
+$META
+EOF
 if [ -z "$ID" ]; then
   case "$URL" in
     *'?v='*|*'&v='*)
@@ -108,13 +136,19 @@ if [ -z "$VTT" ]; then
   done
 fi
 if [ -z "$VTT" ]; then
-  echo "No English captions found for $URL. Falling back is manual (atris youtube process, 5 credits)." >&2
-  exit 2
+  if [ -n "$ID" ] && [ -s "yt_${ID}.clean.txt" ]; then
+    : # leftover cleaned transcript from a prior notes run
+  else
+    echo "No English captions found for $URL. Falling back is manual (atris youtube process, 5 credits)." >&2
+    exit 2
+  fi
 fi
 
 # Strip VTT cruft, drop only nearby rolling-caption duplicates, and keep one
 # time anchor every 30 seconds. Raw auto-captions are mostly timestamp spam:
 # the 21-minute canary is 210 KB raw, 95 KB with the old cleaner, and 22 KB here.
+# Leftover clean.txt is already cleaned; do not overwrite it with an empty VTT pass.
+if [ -n "$VTT" ]; then
 sed -E 's/<[^>]*>//g; s/&gt;/>/g; s/&amp;/\&/g; s/&quot;/"/g' "$VTT" | awk '
 function seconds(ts, parts) {
   split(ts, parts, ":")
@@ -146,6 +180,7 @@ function seconds(ts, parts) {
   for (i = 5; i > 0; i--) recent[i] = recent[i - 1]
   recent[0] = line
 }' > "yt_${ID}.clean.txt"
+fi
 
 TRANSCRIPT=$(<"yt_${ID}.clean.txt")
 

package/utils/api.js

@@ -97,7 +97,7 @@ function httpRequest(urlString, options) {
     // Socket idle timeout (fires if no data received for this duration)
     if (timeoutMs > 0) {
       req.setTimeout(timeoutMs, () => {
-        req.destroy(new Error(`Request timeout after ${Math.round(timeoutMs / 1000)}s — try --timeout=300`));
+        req.destroy(new Error(`request timeout after ${Math.round(timeoutMs / 1000)}s, try --timeout=300`));
       });
     }
     // Hard deadline — kill request after 2x the timeout regardless of activity

package/utils/auth.js

@@ -156,6 +156,20 @@ function mkPrivateDir(dir) {
   return dir;
 }
 
+// Credential files hold login tokens. If they cannot be limited to the owner,
+// say so once per file instead of leaving them readable in silence.
+const permissionWarned = new Set();
+function restrictToOwner(filePath) {
+  try {
+    fs.chmodSync(filePath, 0o600);
+  } catch (err) {
+    if (permissionWarned.has(filePath)) return;
+    permissionWarned.add(filePath);
+    const reason = err && err.code ? ` (${err.code})` : '';
+    console.error(`atris: could not limit ${filePath} to your user${reason}. other users on this machine may be able to read it.`);
+  }
+}
+
 function getAtrisDir() {
   const homeDir = os.homedir();
   return mkPrivateDir(path.join(homeDir, '.atris'));
@@ -202,6 +216,51 @@ function loadPlacedAgentToken() {
   }
 }
 
+function leftoverStoredAgentToken(parsed, envToken) {
+  if (!parsed || !envToken) return null;
+  const leftover = typeof parsed.agent_token === 'string' ? parsed.agent_token.trim() : '';
+  if (!leftover || leftover !== envToken) return null;
+  const expiresAt = parsed.agent_token_expires_at;
+  if (expiryTimeMs(expiresAt) === null) return null;
+  const scopes = Array.isArray(parsed.agent_token_scopes) ? parsed.agent_token_scopes : [];
+  return {
+    token: leftover,
+    expires_at: expiresAt,
+    scopes,
+    provider: null,
+    source: 'env',
+    agent_token: leftover,
+    agent_token_scopes: scopes,
+    agent_token_expires_at: expiresAt,
+  };
+}
+
+function loadLeftoverCredentialsAgentToken(envToken) {
+  if (!envToken) return null;
+  try {
+    return leftoverStoredAgentToken(JSON.parse(fs.readFileSync(getCredentialsPath(), 'utf8')), envToken);
+  } catch {
+    return null;
+  }
+}
+
+function resolveProfileOverride(profileOverride) {
+  if (!profileOverride) return null;
+  if (loadProfile(profileOverride)) return profileOverride;
+  const profiles = listProfiles();
+  const q = String(profileOverride).toLowerCase();
+  return profiles.find((name) => name.toLowerCase() === q)
+    || profiles.find((name) => name.toLowerCase().startsWith(q))
+    || profiles.find((name) => name.toLowerCase().includes(q))
+    || null;
+}
+
+function loadLeftoverProfileAgentToken(envToken) {
+  const name = resolveProfileOverride(process.env.ATRIS_PROFILE) || getSessionProfile();
+  if (!envToken || !name) return null;
+  return leftoverStoredAgentToken(loadProfile(name), envToken);
+}
+
 function isUnexpiredCredential(credentials) {
   const expiresAt = expiryTimeMs(credentials?.expires_at);
   return expiresAt !== null && expiresAt > Date.now();
@@ -304,7 +363,7 @@ function getProfilesDir() {
 
 function profileNameFromEmail(email) {
   if (!email) return null;
-  // "keshav@atrislabs.com" → "keshav"
+  // "alex@example.com" becomes "alex".
   const name = email.split('@')[0].toLowerCase().replace(/[^a-z0-9_-]/g, '-');
   return name || null; // Guard against emails like "@domain.com"
 }
@@ -312,7 +371,7 @@ function profileNameFromEmail(email) {
 function saveProfile(name, credentials) {
   const profilePath = path.join(getProfilesDir(), `${name}.json`);
   fs.writeFileSync(profilePath, JSON.stringify(credentials, null, 2));
-  try { fs.chmodSync(profilePath, 0o600); } catch {}
+  restrictToOwner(profilePath);
 }
 
 function loadProfile(name) {
@@ -368,11 +427,7 @@ function saveCredentials(token, refreshToken, email, userId, provider, extras =
   };
 
   fs.writeFileSync(credentialsPath, JSON.stringify(credentials, null, 2));
-  try {
-    fs.chmodSync(credentialsPath, 0o600);
-  } catch {
-    // Best effort: permissions may be unsupported on this platform.
-  }
+  restrictToOwner(credentialsPath);
 
   // Auto-save as named profile
   autoSaveProfile(credentials);
@@ -417,7 +472,8 @@ async function repairLoginCredentials(credentials, apiRequestJson) {
 function readCredentials() {
   // Priority: ATRIS_TOKEN env var → placed agent token → ATRIS_PROFILE env var
   // → per-terminal session file → global credentials.json. A fresh placed token
-  // overrides a different env token because cloud images can carry a stale one.
+  // overrides env when the leftover is newer or when env only repeats that
+  // leftover, so billed auth still sees leftover scopes.
 
   // 0. Raw token injection. Headless boxes (cloud business computers) have no
   //    browser for `atris login`; the runner injects a scoped token as env
@@ -425,15 +481,24 @@ function readCredentials() {
   const envToken = process.env.ATRIS_TOKEN;
   const normalizedEnvToken = envToken && envToken.trim();
   const placedAgentToken = loadPlacedAgentToken();
-  if (
-    normalizedEnvToken &&
-    placedAgentToken &&
-    placedAgentToken.token !== normalizedEnvToken &&
-    isUnexpiredCredential(placedAgentToken)
-  ) {
+  if (normalizedEnvToken && placedAgentToken && isUnexpiredCredential(placedAgentToken)) {
+    // Fresh placed leftover wins over env, including when env repeats the same
+    // token, so billed auth still sees leftover scopes and does not remint.
     return placedAgentToken;
   }
   if (normalizedEnvToken) {
+    const leftoverCredentials = loadLeftoverCredentialsAgentToken(normalizedEnvToken);
+    if (leftoverCredentials && isUnexpiredCredential(leftoverCredentials)) {
+      // Env repeating leftover credentials.agent_token keeps leftover scopes
+      // and expiry so billed auth does not remint.
+      return leftoverCredentials;
+    }
+    const leftoverProfile = loadLeftoverProfileAgentToken(normalizedEnvToken);
+    if (leftoverProfile && isUnexpiredCredential(leftoverProfile)) {
+      // Env repeating leftover profile or session-profile agent_token keeps
+      // leftover scopes and expiry so billed auth does not remint.
+      return leftoverProfile;
+    }
     return { token: normalizedEnvToken, provider: null, source: 'env' };
   }
 

package/utils/backend-root.js

@@ -0,0 +1,31 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { resolveWorkspaceRoot } = require('../lib/mission-root');
+const { loadConfig } = require('./config');
+
+const BACKEND_ROOT_HINT = 'set ATRIS_BACKEND_ROOT to the backend workspace.';
+
+function resolveBackendRoot(cwd = process.cwd()) {
+  const workspace = resolveWorkspaceRoot(cwd);
+  // ATRIS_BACKEND_DIR is the former spelling, accepted only here.
+  const environment = process.env.ATRIS_BACKEND_ROOT || process.env.ATRIS_BACKEND_DIR;
+  if (environment) {
+    const candidate = path.resolve(environment);
+    return fs.existsSync(candidate) && fs.statSync(candidate).isDirectory() ? candidate : null;
+  }
+
+  const config = loadConfig(workspace);
+  if (typeof config?.backend_root === 'string' && config.backend_root.trim()) {
+    const candidate = path.resolve(workspace, config.backend_root);
+    return fs.existsSync(candidate) && fs.statSync(candidate).isDirectory() ? candidate : null;
+  }
+
+  const sibling = path.resolve(workspace, '..', 'atrisos-backend');
+  if (fs.existsSync(sibling) && fs.statSync(sibling).isDirectory()) return sibling;
+  const installedSibling = path.resolve(__dirname, '..', '..', 'atrisos-backend');
+  return fs.existsSync(installedSibling) && fs.statSync(installedSibling).isDirectory() ? installedSibling : null;
+}
+
+module.exports = { BACKEND_ROOT_HINT, resolveBackendRoot };