atris 3.55.0 → 3.56.1

package/commands/business.js

@@ -3277,11 +3277,14 @@ async function deployBusiness(slug) {
   // Upload workspace files
   const workspaceDir = path.join(bizDir, 'workspace');
   let uploadCount = 0;
+  let uploadFailureCount = 0;
+  let uploadTotal = 0;
   if (fs.existsSync(workspaceDir)) {
     const files = walkDir(workspaceDir);
     for (const filePath of files) {
       const relativePath = path.relative(workspaceDir, filePath);
       if (relativePath.startsWith('.')) continue;
+      uploadTotal++;
       try {
         const content = fs.readFileSync(filePath, 'utf8');
         const uploadResult = await apiRequestJson(
@@ -3291,9 +3294,14 @@ async function deployBusiness(slug) {
         if (uploadResult.ok) {
           uploadCount++;
           process.stdout.write(`  Uploaded: ${relativePath}\n`);
+        } else {
+          uploadFailureCount++;
+          const detail = uploadResult.errorMessage || uploadResult.error || uploadResult.status || 'unknown error';
+          console.log(`  Failed: ${relativePath} (${detail})`);
         }
       } catch (e) {
-        // Skip binary files or errors
+        uploadFailureCount++;
+        console.log(`  Failed: ${relativePath} (${e.message || String(e)})`);
       }
     }
   }
@@ -3314,6 +3322,10 @@ async function deployBusiness(slug) {
 
   console.log(`\n  Deployed ${uploadCount} files to ${bizConfig.name}`);
   console.log(`  Dashboard: https://atris.ai/dashboard/gm/${bizConfig.business_id}`);
+  if (uploadFailureCount > 0) {
+    console.log(`  ${uploadFailureCount} of ${uploadTotal} files failed to upload`);
+    process.exitCode = 1;
+  }
   console.log('');
 }
 

package/commands/fleet-report.js

@@ -15,7 +15,7 @@
 
 const { loadCredentials } = require('../utils/auth');
 const { apiRequestJson } = require('../utils/api');
-const { requireAccountBound, refuseAccountGlobal } = require('../lib/account-bound');
+const { looksLikeBusinessSlug, requireAccountBound, refuseAccountGlobal } = require('../lib/account-bound');
 const { argsWantHelp, wantsJson } = require('../lib/noninteractive');
 
 function sleep(ms) {
@@ -181,7 +181,7 @@ async function fleetReport() {
   const wake = gate.args.includes('--wake');
   const dryRun = gate.args.includes('--dry-run');
   const board = gate.args.includes('--leaderboard');
-  const slug = gate.args.find((a) => !a.startsWith('--'));
+  const slug = gate.args.find((a) => looksLikeBusinessSlug(a));
 
   if (!allAlive && !slug && !board) {
     console.log(usage);

package/commands/human-missions.js

@@ -14,7 +14,7 @@ const {
 const { apiRequestJson } = require('../utils/api');
 const { decodeJwtClaims, loadCredentials } = require('../utils/auth');
 const { isHelpToken } = require('../lib/noninteractive');
-const { isFreshWorkspace, speakFirstMinute } = require('../lib/first-minute');
+const { isFreshWorkspace, speakFirstMinute, speakNothingRunning } = require('../lib/first-minute');
 
 const PACKAGE_PATH = path.join(__dirname, '..', 'package.json');
 const HUMAN_STATES = Object.freeze({
@@ -168,7 +168,8 @@ function parseMissionId(args = []) {
 
 /**
  * Scratch / unbound folders must not drive account-current cloud work.
- * Require an explicit mission/task id: atris stop --mission <id>
+ * Empty-folder stop talks first-talk instead. After a room exists,
+ * require an explicit mission/task id: atris stop --mission <id>
  */
 function refuseUnboundCloudComputer(args = [], options = {}, commandName = 'stop') {
   const root = options.root || process.cwd();
@@ -634,6 +635,15 @@ async function currentMissionCommand(args = [], options = {}) {
     outputCard(card, asJson, options.log || console.log);
     return 0;
   } catch (caught) {
+    if (options.fallbackOnMissing) {
+      const code = speakFirstMinute({
+        root: options.root || process.cwd(),
+        asJson,
+        log: options.log || console.log,
+      });
+      if (options.setProcessExitCode !== false) process.exitCode = code;
+      return code;
+    }
     return reportError(caught, 'show the current mission', asJson, options);
   }
 }
@@ -734,6 +744,20 @@ async function stopCommand(args, options = {}) {
     (options.log || console.log)('Usage: atris stop [--mission <id>] [--json]');
     return 0;
   }
+  const root = options.root || process.cwd();
+  const asJson = args.includes('--json');
+  // Fresh folder: empty talks first-talk. A file already here
+  // names that file, same as bare atris. Do not mint a room.
+  if (isFreshWorkspace(root) && !parseMissionId(args)) {
+    const unbound = refuseUnboundCloudComputer(args, options, 'stop');
+    if (unbound) {
+      return speakNothingRunning({
+        root,
+        asJson,
+        log: options.log || console.log,
+      });
+    }
+  }
   return changeCurrentMission('stop', {}, args, options);
 }
 

package/commands/init.js

@@ -468,41 +468,8 @@ function initAtris() {
     }
   }
 
-  // Create INTUITION.md - captures learnings, preferences, dead ends
-  const intuitionFile = path.join(targetDir, 'INTUITION.md');
-  if (!fs.existsSync(intuitionFile)) {
-    fs.writeFileSync(intuitionFile, `# INTUITION.md
-
-> Accumulated learnings. Read before major decisions. Update after discoveries.
-
----
-
-## Tripwires
-
-*Things that seem obvious but break unexpectedly. Check these first when debugging.*
-
-- (none yet — add when you hit surprising failures)
-
----
-
-## Preferences
-
-*Patterns this codebase prefers. Follow these over generic best practices.*
-
-- (none yet — add as you discover the codebase style)
-
----
-
-## Dead Ends
-
-*Approaches tried and abandoned. Don't retry without new information.*
-
-- (none yet — log failed approaches so future agents skip them)
-
----
-`);
-    markReady('workspace', 'INTUITION.md', '✓ Created INTUITION.md');
-  }
+  // INTUITION.md was retired into lessons.md. Do not write a parallel lesson file.
+  // Leave a user's existing INTUITION.md alone if one is already on disk.
 
   // Create lessons.md (feedback loop for learning across features)
   const lessonsFile = path.join(targetDir, 'lessons.md');

package/commands/integrations.js

@@ -5,6 +5,9 @@
  *   atris gmail inbox [--account <id>]       - List recent emails for a mailbox
  *   atris gmail read <id> [--account <id>]   - Read specific email
  *   atris gmail archive <id> [...] [--account <id>] - Archive messages
+ *   atris gmail verdicts [--account <id>] [--limit N] - List recent archive verdicts
+ *   atris gmail send <to> <subject> <body...> [--body-file <path>] [--account <id>] - Send an email
+ *   atris gmail voice [account] [--clear]    - Edit an account's writing voice
  *   atris gmail connect [name]              - Connect or reconnect a Gmail account
  *   atris gmail accounts                     - List connected Gmail accounts and the active account
  *   atris gmail use [<account_id|name>]      - Choose or set the active Gmail account
@@ -35,6 +38,79 @@ const { spawnSync } = require('child_process');
 const CALENDAR_CACHE_PATH = path.join(os.homedir(), '.atris', 'calendar-events-cache.json');
 const GMAIL_CONNECT_POLL_MS = 3000;
 const GMAIL_CONNECT_TIMEOUT_MS = 3 * 60 * 1000;
+const GMAIL_SEND_USAGE = 'usage: atris gmail send <to> <subject> <body...> [--body-file <path>] [--account <id>]';
+const GMAIL_VOICE_USAGE = 'usage: atris gmail voice [account] [--clear]';
+const GMAIL_VERDICTS_USAGE = 'usage: atris gmail verdicts [--account <id>] [--limit N]';
+
+function gmailVerdictsPath(root = process.cwd()) {
+  return path.join(root, '.atris', 'state', 'gmail-verdicts.jsonl');
+}
+
+function appendGmailVerdicts(verdicts, options = {}) {
+  const rows = Array.isArray(verdicts) ? verdicts : [];
+  if (!rows.length) return;
+  const filePath = options.filePath || gmailVerdictsPath(options.root);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const lines = rows.map((row) => JSON.stringify({
+    ts: row.ts || new Date().toISOString(),
+    account: String(row.account || ''),
+    verdict: 'archive',
+    message_id: String(row.message_id || ''),
+    ...(row.from ? { from: row.from } : {}),
+    ...(row.subject ? { subject: row.subject } : {}),
+  }));
+  fs.appendFileSync(filePath, `${lines.join('\n')}\n`, 'utf8');
+}
+
+function readGmailVerdicts(options = {}) {
+  const filePath = options.filePath || gmailVerdictsPath(options.root);
+  let lines;
+  try {
+    lines = fs.readFileSync(filePath, 'utf8').split('\n').filter(Boolean);
+  } catch (error) {
+    if (error.code === 'ENOENT') return [];
+    throw error;
+  }
+  const account = String(options.account || '').trim();
+  const limit = Number.isInteger(options.limit) ? options.limit : 20;
+  return lines.reduce((rows, line) => {
+    try {
+      const row = JSON.parse(line);
+      if (!account || row.account === account) rows.push(row);
+    } catch {}
+    return rows;
+  }, []).reverse().slice(0, limit);
+}
+
+function printGmailVerdicts(options = {}) {
+  const rows = readGmailVerdicts(options);
+  if (!rows.length) {
+    console.log('no gmail verdicts found.');
+    return rows;
+  }
+  for (const row of rows) {
+    const details = [row.from && `from ${row.from}`, row.subject && `subject ${row.subject}`].filter(Boolean);
+    console.log(`${row.ts} archive ${row.message_id} account ${row.account}${details.length ? `, ${details.join(', ')}` : ''}`);
+  }
+  return rows;
+}
+
+function parseGmailVerdictsArgs(args = []) {
+  let account = null;
+  let limit = 20;
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    const value = String(args[i + 1] || '').trim();
+    if (arg === '--account' && value && !value.startsWith('--')) account = value;
+    else if (arg === '--limit' && /^\d+$/.test(value) && Number(value) > 0) limit = Number(value);
+    else {
+      console.error(GMAIL_VERDICTS_USAGE);
+      process.exit(1);
+    }
+    i += 1;
+  }
+  return { account, limit };
+}
 
 function gmailAccountStatePath() {
   return process.env.ATRIS_GMAIL_ACCOUNT_FILE
@@ -308,9 +384,176 @@ async function gmailArchive(messageIds, options = {}) {
   }
 
   const archived = result.data?.archived ?? result.data?.count ?? ids.length;
+  const responseMessages = [
+    result.data?.messages,
+    result.data?.archived_messages,
+    result.data?.results,
+  ].find(Array.isArray) || [];
+  const metadata = new Map(responseMessages.map((message) => [
+    String(message.id || message.message_id || ''),
+    message,
+  ]));
+  appendGmailVerdicts(ids.map((messageId) => {
+    const message = metadata.get(messageId) || {};
+    return {
+      account: accountId,
+      message_id: messageId,
+      from: message.from || message.sender || undefined,
+      subject: message.subject || undefined,
+    };
+  }));
   console.log(`Archived ${archived} message${archived === 1 ? '' : 's'}. They stay searchable in All Mail.`);
 }
 
+function parseGmailSendArgs(args = []) {
+  let accountId = null;
+  let bodyFile = null;
+  const positional = [];
+
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === '--account' || arg === '--body-file') {
+      const value = String(args[i + 1] || '').trim();
+      if (!value || value.startsWith('--')) {
+        console.error(GMAIL_SEND_USAGE);
+        process.exit(2);
+      }
+      if (arg === '--account') accountId = value;
+      else bodyFile = value;
+      i += 1;
+      continue;
+    }
+    positional.push(arg);
+  }
+
+  const [to, subject, ...bodyParts] = positional;
+  if (!String(to || '').trim()
+    || !String(subject || '').trim()
+    || (bodyFile ? bodyParts.length > 0 : bodyParts.length === 0)) {
+    console.error(GMAIL_SEND_USAGE);
+    process.exit(2);
+  }
+
+  let body = bodyParts.join(' ');
+  if (bodyFile) {
+    try {
+      body = fs.readFileSync(bodyFile, 'utf8');
+    } catch (error) {
+      console.error(`could not read body file "${bodyFile}": ${error.message}`);
+      process.exit(1);
+    }
+  }
+
+  return { to, subject, body, accountId };
+}
+
+async function gmailSend(to, subject, body, options = {}) {
+  const token = await getAuthToken();
+  const accountId = resolveGmailAccountId(options.accountId);
+  const accounts = await fetchGmailAccounts(token);
+  const account = findGmailAccount(accounts, accountId);
+
+  if (!account) {
+    console.error(`gmail account "${accountId}" is not connected.`);
+    process.exit(1);
+  }
+
+  const result = await apiRequestJson('/integrations/gmail/send', {
+    method: 'POST',
+    token,
+    body: { to, subject, body, account_id: accountId },
+  });
+
+  if (!result.ok) {
+    console.error(`could not send gmail message: ${result.error || 'request failed'}`);
+    process.exit(1);
+  }
+
+  const { email, id } = gmailAccountIdentity(account);
+  console.log(`sent to ${to} from ${email || id}`);
+}
+
+function parseGmailVoiceArgs(args = []) {
+  let clear = false;
+  const positional = [];
+  for (const arg of args) {
+    if (arg === '--clear') clear = true;
+    else positional.push(arg);
+  }
+  if (positional.length > 1 || positional.some((arg) => String(arg).startsWith('--'))) {
+    console.error(GMAIL_VOICE_USAGE);
+    process.exit(2);
+  }
+  return { accountId: positional[0] || null, clear };
+}
+
+function editGmailVoice(currentVoice, deps = {}) {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'atris-gmail-voice-'));
+  const voicePath = path.join(tempDir, 'voice.md');
+  let editedVoice;
+  let editorError = null;
+
+  try {
+    fs.writeFileSync(voicePath, currentVoice, 'utf8');
+    const editor = deps.editor || process.env.EDITOR || 'vi';
+    const shell = deps.shell || process.env.SHELL || '/bin/sh';
+    const run = deps.spawnSync || spawnSync;
+    const result = run(shell, ['-c', 'exec $EDITOR "$1"', 'atris-gmail-voice', voicePath], {
+      stdio: 'inherit',
+      env: { ...process.env, EDITOR: editor },
+    });
+    if (result.error || result.status !== 0) {
+      editorError = result.error?.message || `editor exited with status ${result.status}`;
+    } else {
+      editedVoice = fs.readFileSync(voicePath, 'utf8');
+    }
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+
+  if (editorError) {
+    console.error(`could not edit gmail voice: ${editorError}`);
+    process.exit(1);
+  }
+  return editedVoice;
+}
+
+async function gmailVoice(accountId, options = {}) {
+  const token = await getAuthToken();
+  const resolvedAccountId = resolveGmailAccountId(accountId);
+  const accounts = await fetchGmailAccounts(token);
+  const account = findGmailAccount(accounts, resolvedAccountId);
+
+  if (!account) {
+    console.error(`gmail account "${resolvedAccountId}" is not connected.`);
+    process.exit(1);
+  }
+
+  let voiceMd = '';
+  if (!options.clear) {
+    const stdinIsTTY = options.stdinIsTTY === undefined
+      ? Boolean(process.stdin.isTTY)
+      : options.stdinIsTTY;
+    voiceMd = stdinIsTTY
+      ? editGmailVoice(String(account.voice_md || ''), options)
+      : String((options.readStdin || (() => fs.readFileSync(0, 'utf8')))());
+  }
+
+  const { id, name } = gmailAccountIdentity(account);
+  const result = await apiRequestJson(`/integrations/gmail/accounts/${encodeURIComponent(id)}`, {
+    method: 'PATCH',
+    token,
+    body: { voice_md: voiceMd },
+  });
+
+  if (!result.ok) {
+    console.error(`could not ${options.clear ? 'clear' : 'save'} gmail voice: ${result.error || 'request failed'}`);
+    process.exit(1);
+  }
+
+  console.log(`voice ${options.clear ? 'cleared' : 'saved'} for ${name}`);
+}
+
 function openGmailAuthUrl(authUrl, deps = {}) {
   const run = deps.spawnSync || spawnSync;
   const platform = deps.platform || process.platform;
@@ -457,6 +700,21 @@ async function gmailCommand(subcommand, ...args) {
       await gmailArchive(parsed.positional, { accountId: parsed.accountId || undefined });
       break;
     }
+    case 'verdicts': {
+      const parsed = parseGmailVerdictsArgs(args);
+      printGmailVerdicts(parsed);
+      break;
+    }
+    case 'send': {
+      const parsed = parseGmailSendArgs(args);
+      await gmailSend(parsed.to, parsed.subject, parsed.body, { accountId: parsed.accountId || undefined });
+      break;
+    }
+    case 'voice': {
+      const parsed = parseGmailVoiceArgs(args);
+      await gmailVoice(parsed.accountId, { clear: parsed.clear });
+      break;
+    }
     case 'connect':
       await gmailConnect(args[0]);
       break;
@@ -471,6 +729,9 @@ async function gmailCommand(subcommand, ...args) {
       console.log('  atris gmail inbox [--account <id>]       - list recent emails for a mailbox');
       console.log('  atris gmail read <id> [--account <id>]   - read specific email');
       console.log('  atris gmail archive <id> [...] [--account <id>] - archive messages (reversible, all mail keeps them)');
+      console.log('  atris gmail verdicts [--account <id>] [--limit N] - list recent archive verdicts');
+      console.log('  atris gmail send <to> <subject> <body...> [--body-file <path>] [--account <id>] - send an email');
+      console.log('  atris gmail voice [account] [--clear]    - edit or clear an account writing voice');
       console.log('  atris gmail connect [name]               - connect or reconnect a gmail account');
       console.log('  atris gmail accounts                     - list connected gmail accounts and the active account');
       console.log('  atris gmail use [<account_id|name>]      - choose or set the active gmail account');
@@ -1983,10 +2244,15 @@ async function integrationsStatus(args = []) {
 module.exports = {
   gmailCommand,
   gmailConnect,
+  gmailVoice,
   gmailUse,
   extractGmailMailboxAccount,
   parseGmailArgs,
   gmailAccountStatePath,
+  gmailVerdictsPath,
+  appendGmailVerdicts,
+  readGmailVerdicts,
+  printGmailVerdicts,
   calendarCommand,
   twitterCommand,
   slackCommand,

package/commands/land.js

@@ -1,6 +1,7 @@
 const fs = require('fs');
 const path = require('path');
 const { runGit } = require('../lib/git-spawn');
+const { compactErrorPayload, printCliJson } = require('../lib/cli-json');
 const { listWorktrees, statusCounts } = require('./worktree');
 
 const DEFAULT_TTL_DAYS = 7;
@@ -236,14 +237,18 @@ function collectBoard(root, { ttlDays = DEFAULT_TTL_DAYS, staleHours = DEFAULT_S
 // merged branch residue.
 function landSummary(cwd = process.cwd(), ttlDays = DEFAULT_TTL_DAYS) {
   const root = repoRoot(cwd);
-  if (!root) return null;
-  const board = collectBoard(root, { ttlDays, light: true });
-  return {
-    branches: board.summary.active + board.summary.due,
-    due: board.summary.due,
-    stale: board.summary.stale,
-    ttlDays,
-  };
+  if (!root || !hasCommits(root)) return null;
+  try {
+    const board = collectBoard(root, { ttlDays, light: true });
+    return {
+      branches: board.summary.active + board.summary.due,
+      due: board.summary.due,
+      stale: board.summary.stale,
+      ttlDays,
+    };
+  } catch {
+    return null;
+  }
 }
 
 function salvageDir(root) {
@@ -636,6 +641,40 @@ function readFollowingFlag(args, name, fallback = '') {
   return args[idx + 1] || fallback;
 }
 
+const EMPTY_LAND = {
+  not_a_git_repo: 'this folder is not a git repo yet, so there is nothing to land.',
+  no_commits: 'nothing is in the air yet because this folder has no commits.',
+  no_base: 'no master or main branch yet, so there is nothing to land.',
+};
+
+function emptyLandKindFromError(err) {
+  if (err && err.code === 'LAND_NO_BASE') return 'no_base';
+  const msg = String(err && err.message || err || '');
+  if (/not a git/i.test(msg)) return 'not_a_git_repo';
+  if (/no commits/i.test(msg)) return 'no_commits';
+  if (/no master\/main/i.test(msg)) return 'no_base';
+  return '';
+}
+
+function printEmptyLand(kind, json) {
+  const reason = EMPTY_LAND[kind] ? kind : 'no_base';
+  const detail = EMPTY_LAND[reason];
+  if (json) {
+    const payload = compactErrorPayload({ reason, detail });
+    printCliJson(payload, payload, ['--json']);
+  } else {
+    console.log(detail);
+  }
+  return 2;
+}
+
+function finishLandError(err, json) {
+  const kind = emptyLandKindFromError(err);
+  if (kind) return printEmptyLand(kind, json);
+  console.error(String(err && err.message || err).split('\n')[0]);
+  return 2;
+}
+
 function showHelp() {
   console.log('');
   console.log('atris land: the landing, what is actually done vs still in the air');
@@ -666,20 +705,14 @@ function landCommand(args = []) {
     showHelp();
     return 0;
   }
+  const json = args.includes('--json');
   const root = repoRoot();
-  if (!root) {
-    console.error('not a git repository. fix: git init -b main');
-    return 1;
-  }
-  if (!hasCommits(root)) {
-    console.error('no commits yet. fix: git commit --allow-empty -m init');
-    return 1;
-  }
+  if (!root) return printEmptyLand('not_a_git_repo', json);
+  if (!hasCommits(root)) return printEmptyLand('no_commits', json);
   const ttlRaw = readFollowingFlag(args, '--ttl', '');
   const ttlParsed = Number(ttlRaw);
   const ttlDays = ttlRaw !== '' && Number.isFinite(ttlParsed) && ttlParsed >= 0 ? ttlParsed : DEFAULT_TTL_DAYS;
   const base = readFollowingFlag(args, '--base', '');
-  const json = args.includes('--json');
 
   if (args.includes('--reap')) {
     try {
@@ -688,8 +721,7 @@ function landCommand(args = []) {
       else printReceipt(receipt);
       return 0;
     } catch (err) {
-      console.error(String(err && err.message || err));
-      return 1;
+      return finishLandError(err, json);
     }
   }
 
@@ -706,8 +738,7 @@ function landCommand(args = []) {
       else printStory(story);
       return 0;
     } catch (err) {
-      console.error(String(err && err.message || err));
-      return 1;
+      return finishLandError(err, json);
     }
   }
 
@@ -717,8 +748,7 @@ function landCommand(args = []) {
     else printBoard(board);
     return 0;
   } catch (err) {
-    console.error(String(err && err.message || err));
-    return 1;
+    return finishLandError(err, json);
   }
 }
 

package/commands/later.js

@@ -0,0 +1,52 @@
+'use strict';
+
+const { argsWantHelp } = require('../lib/noninteractive');
+const {
+  laterNotePath,
+  listUserVisibleWork,
+  personName,
+  renderLaterRemember,
+  spokenLaterNote,
+  writeLaterNote,
+} = require('../lib/first-minute');
+
+function laterUsage() {
+  return 'Usage: atris later "<sentence>"';
+}
+
+function laterSentence(args = []) {
+  return spokenLaterNote((Array.isArray(args) ? args : [])
+    .filter((arg) => !String(arg).startsWith('-'))
+    .join(' '));
+}
+
+function laterAtris(args = process.argv.slice(3), {
+  root = process.cwd(),
+  log = console.log,
+} = {}) {
+  const list = Array.isArray(args) ? args : [];
+  if (argsWantHelp(list)) {
+    log(laterUsage());
+    return 0;
+  }
+  const sentence = laterSentence(list);
+  if (!sentence) {
+    log(laterUsage());
+    return 2;
+  }
+  writeLaterNote(root, sentence);
+  const files = listUserVisibleWork(root);
+  log('');
+  log(renderLaterRemember({
+    person: personName(),
+    sentence,
+    files,
+    root,
+  }));
+  return 0;
+}
+
+module.exports = {
+  laterAtris,
+  laterNotePath,
+};