atris 3.57.4 → 3.58.6

package/commands/ask.js

@@ -0,0 +1,175 @@
+/**
+ * atris ask: chat with your personal Atris computer.
+ *
+ * Same brain as texting: your memory, calendar, email, and tools.
+ * One-shot:    atris ask what should I do today
+ * Interactive: atris ask
+ */
+
+const readline = require('readline');
+const { getApiBaseUrl, httpRequest, apiRequestJson } = require('../utils/api');
+const auth = require('../utils/auth');
+
+const TIMEOUT_MS = 300000;
+
+function stripEvents(text) {
+  // Drop inline [[EVENT]]{...} tool chatter; keep only the spoken reply.
+  // Tool names are surfaced dimmed in the terminal (texts never see them).
+  if (typeof text !== 'string') return text;
+  const parts = [];
+  const toolNames = [];
+  for (let chunk of text.split('[[EVENT]]')) {
+    const trimmed = chunk.trimStart();
+    if (trimmed.startsWith('{')) {
+      let depth = 0;
+      let inString = false;
+      let escaped = false;
+      let end = -1;
+      for (let i = 0; i < trimmed.length; i += 1) {
+        const ch = trimmed[i];
+        if (escaped) { escaped = false; continue; }
+        if (ch === '\\') { escaped = true; continue; }
+        if (ch === '"') inString = !inString;
+        if (inString) continue;
+        if (ch === '{') depth += 1;
+        if (ch === '}') { depth -= 1; if (depth === 0) { end = i + 1; break; } }
+      }
+      if (end > 0) {
+        try {
+          const evt = JSON.parse(trimmed.slice(0, end));
+          if (evt.type === 'tool_call' && evt.tool) toolNames.push(evt.tool);
+        } catch (_) { /* not JSON, keep going */ }
+        chunk = trimmed.slice(end);
+      }
+    }
+    parts.push(chunk);
+  }
+  const reply = parts.join('').trim();
+  if (toolNames.length && process.stdout.isTTY) {
+    process.stdout.write(`\x1b[2m[⚙ ${[...new Set(toolNames)].join(', ')}]\x1b[0m\n`);
+  }
+  return reply;
+}
+
+function startSpinner(label) {
+  if (!process.stdout.isTTY) return { stop: () => {} };
+  const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+  const started = Date.now();
+  let i = 0;
+  const timer = setInterval(() => {
+    const secs = Math.floor((Date.now() - started) / 1000);
+    process.stdout.write(`\r${frames[i % frames.length]} ${label}${secs > 2 ? ` · ${secs}s` : ''}   `);
+    i += 1;
+  }, 90);
+  return {
+    stop: () => {
+      clearInterval(timer);
+      process.stdout.write('\r\x1b[2K');
+    },
+  };
+}
+
+async function typeOut(text) {
+  if (!process.stdout.isTTY || text.length > 4000) {
+    process.stdout.write(`${text}\n`);
+    return;
+  }
+  for (const ch of text) {
+    process.stdout.write(ch);
+    // eslint-disable-next-line no-await-in-loop
+    await new Promise((r) => setTimeout(r, ch === '\n' ? 12 : 3));
+  }
+  process.stdout.write('\n');
+}
+
+async function sendMessage(token, message) {
+  const res = await httpRequest(`${getApiBaseUrl()}/message/incoming`, {
+    method: 'POST',
+    headers: {
+      Authorization: `Bearer ${token}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({ message, source: 'cli' }),
+    timeoutMs: TIMEOUT_MS,
+  });
+  if (res.status !== 200) {
+    let detail = res.body.toString('utf8').slice(0, 200);
+    try { detail = JSON.parse(detail).detail || detail; } catch (_) { /* raw */ }
+    throw new Error(`HTTP ${res.status}: ${detail}`);
+  }
+  return JSON.parse(res.body.toString('utf8'));
+}
+
+async function askAtris(args) {
+  const ensured = await auth.ensureValidCredentials(apiRequestJson);
+  if (ensured.error === 'not_logged_in' || !ensured.credentials?.token) {
+    console.error('✗ Not logged in. Run "atris login" first.');
+    process.exit(1);
+  }
+  if (ensured.error) {
+    console.error(`✗ Authentication failed: ${ensured.detail || ensured.error}. Run "atris login".`);
+    process.exit(1);
+  }
+  const { token } = ensured.credentials;
+
+  const oneShot = (args || []).join(' ').trim();
+  if (oneShot === '-h' || oneShot === '--help' || oneShot === 'help') {
+    console.log('Usage: atris ask ["message"]');
+    console.log('');
+    console.log('  Chat with your personal Atris computer: memory, calendar, email, tools.');
+    console.log('');
+    console.log('  atris ask                      Interactive chat');
+    console.log('  atris ask what is on today     One-shot question');
+    return;
+  }
+
+  if (oneShot) {
+    const spinner = startSpinner('thinking');
+    try {
+      const body = await sendMessage(token, oneShot);
+      spinner.stop();
+      await typeOut(stripEvents(body.response) || JSON.stringify(body));
+    } catch (err) {
+      spinner.stop();
+      console.error(`✗ ${err.message}`);
+      process.exit(1);
+    }
+    return;
+  }
+
+  console.log('Chatting with your computer. Ctrl-C or "bye" to leave.\n');
+  await new Promise((resolve) => {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  let busy = false;
+  let closed = false;
+  const prompt = () => { if (!closed) rl.question('you › ', onLine); };
+  async function onLine(line) {
+    const message = line.trim();
+    if (!message) { prompt(); return; }
+    if (['bye', 'exit', 'quit'].includes(message.toLowerCase())) { rl.close(); return; }
+    busy = true;
+    const spinner = startSpinner('thinking');
+    try {
+      const body = await sendMessage(token, message);
+      spinner.stop();
+      process.stdout.write('\natris › ');
+      await typeOut(stripEvents(body.response) || JSON.stringify(body));
+      process.stdout.write('\n');
+    } catch (err) {
+      spinner.stop();
+      console.error(`✗ ${err.message}\n`);
+    }
+    busy = false;
+    if (closed) { console.log('\nbye.'); resolve(); return; }
+    prompt();
+  }
+  rl.on('close', () => {
+    closed = true;
+    // Let an in-flight answer finish printing before we leave.
+    if (!busy) { console.log('\nbye.'); resolve(); }
+  });
+  prompt();
+  });
+}
+
+module.exports = { askAtris };

package/commands/auth.js

@@ -1,4 +1,4 @@
-const { AGENT_TOKEN_EXPIRED_DETAIL, loadCredentials, saveCredentials, deleteCredentials, getCredentialsPath, openBrowser, promptUser, displayAccountSummary, ensureValidCredentials, loadProfile, listProfiles, profileNameFromEmail, deleteProfile, saveProfile, getTokenExpiryEpochSeconds, getTerminalSessionId, setSessionProfile, getSessionProfile, clearSessionProfile, cleanStaleSessions, getSessionsDir } = require('../utils/auth');
+const { AGENT_TOKEN_EXPIRED_DETAIL, decodeJwtClaims, loadCredentials, saveCredentials, deleteCredentials, getCredentialsPath, openBrowser, promptUser, displayAccountSummary, ensureValidCredentials, loadProfile, listProfiles, profileNameFromEmail, deleteProfile, saveProfile, getTokenExpiryEpochSeconds, getTerminalSessionId, setSessionProfile, getSessionProfile, clearSessionProfile, cleanStaleSessions, getSessionsDir } = require('../utils/auth');
 const { getAppBaseUrl, apiRequestJson } = require('../utils/api');
 const { isNonInteractive, wantsJson } = require('../lib/noninteractive');
 const { hasFlag, readFlag } = require('../lib/arg-parser');
@@ -85,20 +85,45 @@ function extractAgentTokenMeta(data, requested, token) {
   return { scopes, dailyCreditCap, expiresAt };
 }
 
+function isAgentAccessToken(token) {
+  return decodeJwtClaims(token)?.type === 'agent_access';
+}
+
+function scopedTokenCandidate(credentials = {}) {
+  if (credentials.agent_token) return credentials.agent_token;
+  if (
+    credentials.source === 'env'
+    || credentials.source === 'agent_token_file'
+    || isAgentAccessToken(credentials.token)
+  ) {
+    return firstNonEmptyString(credentials.token);
+  }
+  return null;
+}
+
+function canMintFromLogin(credentials = {}) {
+  const login = firstNonEmptyString(credentials.token);
+  const refresh = firstNonEmptyString(credentials.refresh_token);
+  if (isAgentAccessToken(login) && !refresh) return false;
+  return Boolean(login || refresh);
+}
+
 function persistMintedAgentToken(credentials, token, extras = {}) {
+  if (isAgentAccessToken(credentials.token)) {
+    throw new Error('Refusing to save a scoped agent token as the login token; keep it under agent_token');
+  }
   const next = {
-    token,
+    ...credentials,
     refresh_token: extras.refresh_token || credentials.refresh_token || null,
-    email: credentials.email || null,
-    user_id: credentials.user_id || null,
-    provider: credentials.provider || null,
-    saved_at: extras.saved_at || new Date().toISOString(),
+    agent_token: token,
+    agent_token_scopes: extras.scopes || [],
+    agent_token_expires_at: extras.expiresAt || null,
   };
   if (credentials.source_profile) {
     saveProfile(credentials.source_profile, next);
     return next;
   }
-  saveCredentials(next.token, next.refresh_token, next.email, next.user_id, next.provider);
+  saveCredentials(next.token, next.refresh_token, next.email, next.user_id, next.provider, next);
   return next;
 }
 
@@ -139,10 +164,10 @@ async function mintScopedAgentToken(requested = {}, deps = {}) {
     ? requested.dailyCreditCap
     : DEFAULT_DAILY_CREDIT_CAP;
 
-  const credentials = load() || {};
+  const credentials = await load(api) || {};
   const accessToken = firstNonEmptyString(credentials.token);
   const refreshToken = firstNonEmptyString(credentials.refresh_token);
-  if (!accessToken && !refreshToken) {
+  if (!canMintFromLogin(credentials)) {
     return { ok: false, code: 'not_logged_in', error: NO_STORED_JWT_MESSAGE };
   }
 
@@ -150,7 +175,7 @@ async function mintScopedAgentToken(requested = {}, deps = {}) {
     scopes,
     daily_credit_cap: dailyCreditCap,
   };
-  let authToken = accessToken || refreshToken;
+  let authToken = isAgentAccessToken(accessToken) ? refreshToken : (accessToken || refreshToken);
   let result = await postAgentToken(api, authToken, body);
   if (!result.ok && result.status === 401 && refreshToken && authToken !== refreshToken) {
     authToken = refreshToken;
@@ -172,7 +197,9 @@ async function mintScopedAgentToken(requested = {}, deps = {}) {
     return { ok: false, code: 'missing_token', error: 'backend did not return an agent token' };
   }
 
+  const meta = extractAgentTokenMeta(result.data, { scopes, dailyCreditCap }, minted);
   persist(credentials, minted, {
+    ...meta,
     refresh_token: firstNonEmptyString(result.data && result.data.refresh_token) || refreshToken,
     saved_at: now(),
   });
@@ -180,7 +207,8 @@ async function mintScopedAgentToken(requested = {}, deps = {}) {
   return {
     ok: true,
     token: minted,
-    meta: extractAgentTokenMeta(result.data, { scopes, dailyCreditCap }, minted),
+    meta,
+    storedIn: credentials.source_profile ? `profile ${credentials.source_profile}, agent_token` : '~/.atris/credentials.json, agent_token',
   };
 }
 
@@ -191,24 +219,21 @@ async function ensureBilledCommandAuth(scope, deps = {}) {
   }
 
   const api = deps.apiRequestJson || apiRequestJson;
-  const ensureFn = deps.ensureValidCredentials || ensureValidCredentials;
   const load = deps.loadCredentials || loadCredentials;
   const mint = deps.mintScopedAgentToken || mintScopedAgentToken;
 
-  if (!deps.forceMint) {
-    const ensured = await ensureFn(api);
-    if (ensured && ensured.credentials && ensured.credentials.token) {
-      return {
-        ok: true,
-        token: ensured.credentials.token,
-        minted: false,
-        credentials: ensured.credentials,
-      };
-    }
+  const ensured = !deps.forceMint && deps.ensureValidCredentials
+    ? await deps.ensureValidCredentials(api) : null;
+  const credentials = ensured?.credentials || await load(api) || {};
+  const candidate = scopedTokenCandidate(credentials);
+  const claims = decodeJwtClaims(candidate);
+  const scopes = claims?.scopes || credentials.agent_token_scopes || [];
+  const expiry = claims?.exp ? claims.exp * 1000 : Date.parse(credentials.agent_token_expires_at);
+  if (!deps.forceMint && candidate && Array.isArray(scopes) && scopes.includes(wanted) && Number.isFinite(expiry) && expiry > Date.now()) {
+    return { ok: true, token: candidate, minted: false, credentials };
   }
 
-  const credentials = load() || {};
-  if (!firstNonEmptyString(credentials.token, credentials.refresh_token)) {
+  if (!canMintFromLogin(credentials)) {
     return { ok: false, error: NO_STORED_JWT_MESSAGE };
   }
 
@@ -267,6 +292,7 @@ async function mintAgentToken(args = [], deps = {}) {
     output(JSON.stringify({
       ok: true,
       minted: true,
+      stored_in: minted.storedIn,
       scopes: minted.meta.scopes,
       daily_credit_cap: minted.meta.dailyCreditCap,
       expires_at: minted.meta.expiresAt,
@@ -275,6 +301,7 @@ async function mintAgentToken(args = [], deps = {}) {
   }
 
   printAgentTokenMint(minted.meta, output);
+  output(`stored in ${minted.storedIn}`);
   return 0;
 }
 
@@ -565,7 +592,7 @@ async function switchAccount() {
       const profile = loadProfile(name);
       const email = profile?.email || 'unknown';
       const marker = name === currentName ? '  ← active' : '';
-      console.log(`  ${i + 1}. ${name} — ${email}${marker}`);
+      console.log(`  ${i + 1}. ${name}, ${email}${marker}`);
     });
     console.log(`  ${profiles.length + 1}. Add new account`);
     console.log(`  ${profiles.length + 2}. Cancel`);
@@ -620,13 +647,13 @@ function activateProfile(name, currentName, { global = false } = {}) {
   }
 
   if (global || !getTerminalSessionId()) {
-    // Global switch — write to credentials.json (affects all terminals)
+    // Global switch, write to credentials.json (affects all terminals)
     const credentialsPath = getCredentialsPath();
     fs.writeFileSync(credentialsPath, JSON.stringify(profile, null, 2));
     try { fs.chmodSync(credentialsPath, 0o600); } catch {}
-    console.log(`Switched to ${profile.email || name} (global — all terminals)`);
+    console.log(`Switched to ${profile.email || name} (global, all terminals)`);
   } else {
-    // Per-terminal switch — write session file (only this terminal)
+    // Per-terminal switch, write session file (only this terminal)
     setSessionProfile(name);
     console.log(`Switched to ${profile.email || name}`);
   }
@@ -682,7 +709,7 @@ function useAccount() {
   if (!process.stdout.isTTY) {
     process.stdout.write(`export ATRIS_PROFILE=${match}\n`);
   } else {
-    // Interactive — print instructions
+    // Interactive, print instructions
     console.log(`export ATRIS_PROFILE=${match}`);
     console.log(`\n# Run this to activate ${email} in this terminal:`);
     console.log(`#   eval "$(atris use ${targetName})"`);
@@ -893,7 +920,7 @@ function switchSession() {
     if (termId) {
       setSessionProfile(name);
     } else {
-      // No terminal ID — global fallback
+      // No terminal ID, global fallback
       const credentialsPath = getCredentialsPath();
       fs.writeFileSync(credentialsPath, JSON.stringify(profile, null, 2));
       try { fs.chmodSync(credentialsPath, 0o600); } catch {}
@@ -910,7 +937,7 @@ function shellInit() {
     '# Atris per-terminal account switching',
     '# Added by: eval "$(atris shell-init)"',
     '_atris_session_id() {',
-    '  # Detect terminal session ID — same priority as the Node.js code',
+    '  # Detect terminal session ID, same priority as the Node.js code',
     '  local _sid="${TERM_SESSION_ID:-${ITERM_SESSION_ID:-${TMUX_PANE:-${WT_SESSION:-${WEZTERM_PANE:-}}}}}"',
     '  if [[ -n "$_sid" ]]; then echo "$_sid"; return; fi',
     '  # Fallback: TTY device (unique per macOS/Linux terminal tab)',
@@ -982,6 +1009,7 @@ module.exports = {
   shellInit,
   parseAgentTokenArgs,
   mintAgentToken,
+  persistMintedAgentToken,
   ensureBilledCommandAuth,
   wantsAgentToken,
 };

package/commands/autoland.js

@@ -752,7 +752,7 @@ async function runTickBody(root, { json, policy, receipt, engineValidationDeps =
   // the landing gate reuse the live certification verifier result without
   // persisting trust across heartbeats. Denied lanes and check-less proofs wait.
   // No hardcoded --limit here: a fixed low cap (this used to be 12) silently
-  // undercounts a real backlog every single tick — 12/hour forever even with
+  // undercounts a real backlog every single tick: 12/hour forever even with
   // 78 certified rows waiting. Let `atris task auto-accept-certified` apply
   // its own default (12 without --all, a high safety cap under --all) so a
   // policy with accept_all:true actually drains the full certified set.
@@ -763,7 +763,7 @@ async function runTickBody(root, { json, policy, receipt, engineValidationDeps =
   try {
     const parsed = JSON.parse(accept.stdout);
     const results = Array.isArray(parsed.results) ? parsed.results : [];
-    // A refused sweep (ok:false — a guard tripped, policy race) carries no
+    // A refused sweep (ok:false, a guard tripped, policy race) carries no
     // summary fields. Name the reason instead of leaving nulls that read as
     // "no work": a blind heartbeat must say WHY it is blind.
     if (parsed.ok === false) {
@@ -841,7 +841,7 @@ async function runTickBody(root, { json, policy, receipt, engineValidationDeps =
   }
 
   // 3b. janitor, every tick: a mission left paused past 48h and a worktree
-  // already merged into base are the same rot pattern as an unlanded branch —
+  // already merged into base are the same rot pattern as an unlanded branch,
   // left alone they accumulate until a human runs `mission stop` and
   // `worktree cleanup --apply` by hand, which is exactly the chore autoland
   // exists to remove. Off switch: policy.janitor === false (default on, the
@@ -880,6 +880,30 @@ async function runTickBody(root, { json, policy, receipt, engineValidationDeps =
     recordJanitorState(state, { stopped: stoppedMissions, held: heldMissions, worktrees: receipt.worktrees_reaped });
   }
 
+  // 3b2. green landing, every tick: one stale branch that merges clean and
+  // passes the full verify in a scratch checkout lands on base and is pushed.
+  // A red branch opens a close flag the same hour instead of waiting for the
+  // TTL reap to salvage it. Off by policy: green_landing:false.
+  if (policy.green_landing !== false) {
+    try {
+      const { landStaleGreenBranches, summaryLine } = require('../lib/land-green');
+      const green = landStaleGreenBranches(root, {
+        verifyCommand: policy.verify_command || undefined,
+        limit: Number(policy.green_landing_limit) > 0 ? Number(policy.green_landing_limit) : 1,
+      });
+      receipt.green_landing = {
+        candidates: green.candidates.length,
+        landed: green.landed,
+        red: green.red,
+        verdicts: green.verdicts.map((v) => ({ branch: v.branch, action: v.action, reason: v.reason || null, detail: v.detail || null, failing: v.verify ? v.verify.failing : undefined })),
+        summary: summaryLine(green),
+      };
+      state.green_landing = { at: green.at, ...receipt.green_landing };
+    } catch (err) {
+      receipt.green_landing_error = String((err && err.message) || err).slice(0, 200);
+    }
+  }
+
   // 3c. landing sweep, every tick: merged branch residue is cleared,
   // TTL-expired work is salvaged before deletion, and 48h-stale active work
   // is carried into the digest instead of silently aging forever.
@@ -952,7 +976,7 @@ async function runTickBody(root, { json, policy, receipt, engineValidationDeps =
     }
   }
 
-  // 5b. daily keep/revert experiment — self-gated inside experiments daily;
+  // 5b. daily keep/revert experiment, self-gated inside experiments daily;
   // hourly ticks are harmless no-ops after the first run each day.
   if (policy.daily_experiment !== false) {
     const daily = runOwnCli(root, ['experiments', 'daily', '--json']);
@@ -1021,7 +1045,7 @@ async function runTickBody(root, { json, policy, receipt, engineValidationDeps =
     // Deltas alone ("0 certified, 0 landed") are true and useless: they read
     // as "nothing to do" whether the queue is empty or 19-deep and wedged.
     // Always print the standing backlog, and name work that cleared every
-    // gate and still did not land — that is the shape of a stuck loop.
+    // gate and still did not land. That is the shape of a stuck loop.
     const stuckNote = stuckBacklogNote(receipt);
     const summary = `autoland tick: ${receipt.reviews_certified ?? 0} reviews certified, ${receipt.landed.length} landed${receipt.landed.length ? ` (${receipt.landed.join(', ')})` : ''}, ${receipt.alarms} alarms${stuckNote}, digest ${digestTickStatus(receipt)}${reapNote}${janitorNote}${heldNote}${wishNote}${engineSweepNote}${receiptNote}`;
     const validationLine = engineAnswerValidationLine(receipt);

package/commands/autopilot-front.js

@@ -1,6 +1,6 @@
 // atris autopilot: point it at the workspace and it keeps going.
-// Each leg picks the most logical work — a moving mission first, then a
-// member choosing useful work, then a self-chosen mission — and drives it
+// Each leg picks the most logical work, a moving mission first, then a
+// member choosing useful work, then a self-chosen mission, and drives it
 // through the mission runtime. It loops until stopped:
 //   atris autopilot stop   (from any terminal)  or Ctrl-C here.
 // The old suggest→justify→execute loop lives on behind `atris autopilot --legacy`.
@@ -57,7 +57,7 @@ function positiveNumber(value) {
   return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
 }
 
-// `--iterations=N` or `--iterations N` — the leg cap legacy callers pass.
+// `--iterations=N` or `--iterations N`, the leg cap legacy callers pass.
 function maxLegsFlag(args) {
   const eq = args.find((a) => typeof a === 'string' && a.startsWith('--iterations='));
   if (eq) return positiveNumber(eq.split('=')[1]);
@@ -187,7 +187,7 @@ function autopilotStatus(root = process.cwd()) {
   const state = readState(root);
   if (!state) { console.log('Autopilot is not running.'); return 0; }
   const alive = pidAlive(state.pid);
-  console.log(`Autopilot ${alive ? 'running' : 'not running (stale state)'} — pid ${state.pid}, started ${state.started_at}, legs ${state.legs || 0}`);
+  console.log(`Autopilot ${alive ? 'running' : 'not running (stale state)'}, pid ${state.pid}, started ${state.started_at}, legs ${state.legs || 0}`);
   if (state.current_leg) console.log(`Current leg: ${state.current_leg}`);
   if (!alive) clearState(root);
   return 0;
@@ -276,7 +276,7 @@ async function autopilotFront(args = []) {
 
   const current = { child: null };
   // `autopilot stop` SIGTERMs this pid directly, so the farewell must print
-  // here — the signal always beats the loop's own stop-file check.
+  // here, the signal always beats the loop's own stop-file check.
   const onSignal = () => {
     if (current.child) { try { current.child.kill('SIGTERM'); } catch {} }
     const reason = stopRequested(root) ? 'stop requested' : 'interrupted';
@@ -314,7 +314,7 @@ async function autopilotFront(args = []) {
     if (maxLegs && state.legs >= maxLegs) { stopReason = `leg cap reached (--iterations=${maxLegs})`; break; }
     if (stopRequested(root)) { stopReason = 'stop requested'; break; }
 
-    // A leg that finishes in seconds means no real work happened — a crash,
+    // A leg that finishes in seconds means no real work happened, a crash,
     // or a degenerate mission whose ticks record instantly (exit 0). Either
     // way, back off and stop instead of hot-looping on it.
     const legSeconds = (Date.now() - legStarted) / 1000;