atris 3.55.0 → 3.56.1

package/commands/now.js

@@ -576,6 +576,31 @@ function refreshNowFile(root = process.cwd(), options = {}) {
   return { path: nowPath, preserved: false };
 }
 
+function stripAnsi(text) {
+  return String(text || '').replace(/\u001b\[[0-9;]*m/g, '');
+}
+
+function spokenCurrent(text) {
+  const line = stripAnsi(text).split(/\n/).map((part) => part.trim()).find(Boolean) || '';
+  return line.replace(/^hey\s+[^,]+,\s*/i, '').replace(/\.$/, '');
+}
+
+function printNowJson(payload) {
+  console.log(JSON.stringify(payload, null, 2));
+}
+
+function nowJsonPayload(root = process.cwd()) {
+  const { buildFirstMinute, isFreshWorkspace } = require('../lib/first-minute');
+  const fresh = isFreshWorkspace(root);
+  const screen = buildFirstMinute({ root, fresh });
+  const payload = { ok: !fresh };
+  const current = spokenCurrent(screen && screen.text);
+  const next = stripAnsi(screen && screen.nextCommand);
+  if (current) payload.current = current;
+  if (next) payload.next = next;
+  return payload;
+}
+
 function nowAtris(args = process.argv.slice(3), root = process.cwd()) {
   const help = args.includes('--help') || args.includes('-h') || args[0] === 'help';
   if (help) {
@@ -588,8 +613,8 @@ function nowAtris(args = process.argv.slice(3), root = process.cwd()) {
     console.log('  atris now --refresh Regenerate a small local now.md');
     console.log('  atris now --all     Refresh this parent and every child Atris workspace');
     console.log('  atris now --path    Print the file path only');
-    console.log('  atris now --json    Emit path and content as JSON');
-    return;
+    console.log('  atris now --json    Print ok, next or current as JSON');
+    return 0;
   }
 
   const init = args.includes('--init');
@@ -598,48 +623,65 @@ function nowAtris(args = process.argv.slice(3), root = process.cwd()) {
   const pathOnly = args.includes('--path');
   const asJson = args.includes('--json');
 
-  let result;
-  if (all) {
-    const workspaces = findChildWorkspaces(root);
-    for (const workspace of workspaces) {
-      refreshNowFile(workspace.root);
+  try {
+    if (asJson && !init && !refresh && !all && !pathOnly) {
+      const payload = nowJsonPayload(root);
+      printNowJson(payload);
+      return payload.ok ? 0 : 2;
     }
-    result = refreshNowFile(root);
-    if (!pathOnly && !asJson) {
-      console.log(`Refreshed ${workspaces.length} child workspace${workspaces.length === 1 ? '' : 's'}.`);
-      console.log('');
+
+    let result;
+    if (all) {
+      const workspaces = findChildWorkspaces(root);
+      for (const workspace of workspaces) {
+        refreshNowFile(workspace.root);
+      }
+      result = refreshNowFile(root);
+      if (!pathOnly && !asJson) {
+        console.log(`Refreshed ${workspaces.length} child workspace${workspaces.length === 1 ? '' : 's'}.`);
+        console.log('');
+      }
+    } else if (refresh) {
+      result = refreshNowFile(root);
+    } else if (init) {
+      result = ensureNowFile(root);
+    } else {
+      result = ensureNowFile(root);
     }
-  } else if (refresh) {
-    result = refreshNowFile(root);
-  } else if (init) {
-    result = ensureNowFile(root);
-  } else {
-    result = ensureNowFile(root);
-  }
 
-  const rel = path.relative(root, result.path);
-  if (pathOnly) {
-    console.log(rel);
-    return;
-  }
+    const rel = path.relative(root, result.path);
+    if (pathOnly) {
+      console.log(rel);
+      return 0;
+    }
 
-  const content = fs.readFileSync(result.path, 'utf8').trimEnd();
-  if (asJson) {
-    console.log(JSON.stringify({
-      ok: true,
-      path: rel,
-      created: Boolean(result.created),
-      content,
-    }, null, 2));
-    return;
-  }
+    if (asJson) {
+      const payload = nowJsonPayload(root);
+      printNowJson(payload);
+      return payload.ok ? 0 : 2;
+    }
 
-  if (result.created) {
-    console.log(`Created ${rel}`);
-    console.log('');
-  }
+    const content = fs.readFileSync(result.path, 'utf8').trimEnd();
+    if (result.created) {
+      console.log(`Created ${rel}`);
+      console.log('');
+    }
 
-  console.log(content);
+    console.log(content);
+    return 0;
+  } catch (err) {
+    const message = stripAnsi(err && err.message ? err.message : String(err));
+    if (asJson) {
+      printNowJson({
+        ok: false,
+        current: message.replace(/\.$/, ''),
+        next: 'atris init --yes',
+      });
+      return 2;
+    }
+    console.error(message);
+    return 1;
+  }
 }
 
 module.exports = {

package/commands/recap.js

@@ -1,6 +1,15 @@
 const fs = require('fs');
 const path = require('path');
-const { isCertifiedReview, personName } = require('../lib/first-minute');
+const {
+  isCertifiedReview,
+  isFreshWorkspace,
+  isKeepWorkingMinute,
+  buildFirstMinute,
+  listUserVisibleWork,
+  personName,
+  speakFirstMinute,
+  speakKeepWorkingMinute,
+} = require('../lib/first-minute');
 const { isRealTestRunnerProof, quoteVerifierCommand } = require('../lib/verifier-quality');
 
 const DAY_MS = 24 * 60 * 60 * 1000;
@@ -241,6 +250,20 @@ function recapSoftTitle(title, maxWords = 5) {
   return `"${text.toLowerCase()}"`;
 }
 
+function hasLiveKeepWorkingRun(root = process.cwd()) {
+  try {
+    const { pickLiveLocalMission } = require('./mission');
+    return Boolean(pickLiveLocalMission(root));
+  } catch {
+    return false;
+  }
+}
+
+function pickSpokenInProgress(items) {
+  const list = Array.isArray(items) ? items.filter(Boolean) : [];
+  return list.find((item) => item.owner) || list[0] || null;
+}
+
 function renderRecapMinute(data, { person } = {}) {
   const who = person != null ? person : personName();
   const greet = who ? `hey ${who}, ` : '';
@@ -290,9 +313,15 @@ function renderRecapMinute(data, { person } = {}) {
   }
 
   if (inProgress.length) {
-    const item = inProgress[0];
+    const item = pickSpokenInProgress(inProgress);
     const named = recapSoftTitle(item && item.title);
-    if (item && item.owner && named) return `${greet}${named} is already yours.`;
+    if (item && item.owner && named) {
+      return [
+        `${greet}${named} is already yours.`,
+        '',
+        'next: atris do',
+      ].join('\n');
+    }
     if (named) return `${greet}${named} is ready to claim.`;
   }
 
@@ -319,9 +348,42 @@ function recapAtris(args = []) {
     printRecapHelp();
     return;
   }
+  const root = process.cwd();
+  const visibleBefore = listUserVisibleWork(root);
   const daysIdx = args.indexOf('--days');
   const days = daysIdx !== -1 ? Number(args[daysIdx + 1]) : DEFAULT_DAYS;
-  const data = buildRecapData(process.cwd(), { days });
+  const data = buildRecapData(root, { days });
+  if (
+    data.empty
+    && isFreshWorkspace(root)
+    && !args.includes('--verbose')
+    && !args.includes('--full')
+    && !args.includes('--share')
+  ) {
+    return speakFirstMinute({
+      root,
+      asJson: args.includes('--json'),
+      files: visibleBefore,
+    });
+  }
+  // Just-minted file folder, nothing running: same two lines as
+  // first-minute / status / the next do. Not factory MAP.md.
+  // A claimed non-seed task still recaps that work. A live mission
+  // and --verbose / --share keep the recap report.
+  if (
+    !args.includes('--verbose')
+    && !args.includes('--full')
+    && !args.includes('--share')
+    && !hasLiveKeepWorkingRun(root)
+  ) {
+    const minute = buildFirstMinute({ root, files: visibleBefore });
+    if (isKeepWorkingMinute(minute)) {
+      return speakKeepWorkingMinute({
+        root,
+        asJson: args.includes('--json'),
+      });
+    }
+  }
   if (args.includes('--json')) {
     console.log(JSON.stringify(data, null, 2));
     return;

package/commands/run-front.js

@@ -1,9 +1,12 @@
 // atris run: thin front door over the mission runtime loop.
 // One bounded pursuit: start a mission from the objective (or resume the most
-// logical runnable mission), tick it, complete on pass, then exit.
+// logical runnable mission after --yes), then exit.
+// A hours / keep-working mission is never started from a bare invoke.
 // The old plan→do→review loop lives on behind `atris run --legacy`.
 const path = require('path');
 const { spawnSync } = require('child_process');
+const { hasYesFlag, wantsJson } = require('../lib/noninteractive');
+const { speakFirstMinute } = require('../lib/first-minute');
 
 const CLI_PATH = path.join(__dirname, '..', 'bin', 'atris.js');
 
@@ -91,6 +94,14 @@ function pickRunnableMission(root = process.cwd(), missionMap = null, options =
   return candidates[0] || null;
 }
 
+function isHoursMission(mission) {
+  if (!mission) return false;
+  if (mission.overnight_loop) return true;
+  const text = `${mission.objective || ''} ${mission.stop_condition || ''}`;
+  if (/\b(overnight|nonstop|forever|goal\s+after\s+goal|self[-\s]?improve)\b/i.test(text)) return true;
+  return /\bhours?\b/i.test(text);
+}
+
 function runTickBudget(args, budgetSeconds) {
   const explicit = positiveNumber(readValueFlag(args, '--max-ticks'));
   if (explicit) return Math.floor(explicit);
@@ -122,14 +133,17 @@ async function runMissionFront(args = []) {
     return result.ok ? 0 : 1;
   }
 
+  // Bare `atris run` talks like the desk. A long keep-working mission
+  // needs an objective or an explicit --yes. Headless never prompts.
+  if (!hasYesFlag(args)) {
+    return speakFirstMinute({ asJson: wantsJson(args) });
+  }
+
   const mission = pickRunnableMission(process.cwd(), null, {
     allowCallerSessionRunners: liveCodexSession(),
   });
   if (!mission) {
-    console.log('No objective given and no runnable mission found.');
-    console.log('Start one: atris run "<objective>" [--minutes N] [--owner <member>]');
-    console.log('Or keep going indefinitely: atris autopilot');
-    return 1;
+    return speakFirstMinute({ asJson: wantsJson(args) });
   }
   console.log(`Resuming mission ${mission.id} (${mission.status}): ${mission.objective}`);
   const result = spawnSync(process.execPath, [
@@ -144,6 +158,7 @@ async function runMissionFront(args = []) {
 module.exports = {
   runMissionFront,
   pickRunnableMission,
+  isHoursMission,
   runObjective,
   runBudgetSeconds,
   runTickBudget,

package/commands/spaceship.js

@@ -13,17 +13,42 @@
  *   atris spaceship --hours 4 --repo /path/to/repo --interval 780 --yes
  *   atris spaceship --hours 0.01 --tick-cmd /tmp/stub.sh --no-email --yes
  *
- * Without --yes, spaceship only prints the plan (no email, no overnight run).
+ * Without --yes, spaceship only talks the keep-working plan (no email, no run).
  * `--json` without --yes prints a JSON refuse and still does not start.
+ * `--yes` from an unbound scratch folder refuses: that folder is not a room.
  */
 
 const path = require('path');
 const fs = require('fs');
 const { spawn } = require('child_process');
 const { hasYesFlag, argsWantHelp, wantsJson } = require('../lib/noninteractive');
+const { isUnboundScratchFolder, refuseUnboundScratch } = require('../lib/scratch-root');
+const { resolveWorkspaceRoot } = require('../lib/mission-root');
+const { personName } = require('../lib/first-minute');
 
 const SCRIPT = path.join(__dirname, '..', 'scripts', 'spaceship.sh');
 
+function greet(person) {
+  return person ? `hey ${person}, ` : '';
+}
+
+function readFlagValue(args, name) {
+  const list = Array.isArray(args) ? args : [];
+  const idx = list.indexOf(name);
+  const raw = idx !== -1 && list[idx + 1] && !String(list[idx + 1]).startsWith('-')
+    ? String(list[idx + 1]).trim()
+    : '';
+  return raw;
+}
+
+function spokenHours(raw) {
+  const text = raw === undefined || raw === null ? '4' : String(raw).trim();
+  const n = Number(text);
+  if (!Number.isFinite(n) || n <= 0) return '4 hours';
+  if (n === 1) return `${text} hour`;
+  return `${text} hours`;
+}
+
 function printUsage() {
   const lines = [
     'Usage: atris spaceship [--hours N] [--interval SEC] [--repo PATH]',
@@ -31,25 +56,34 @@ function printUsage() {
     '                       [--idle-alert N] [--halt-alert N] [--label NAME]',
     '                       [--no-email] [--yes]',
     '',
-    'Bounded overnight runner. Survives bad ticks and emails on state changes.',
-    'Without --yes, prints the plan only (no email, no overnight run).',
-    'Defaults: --hours 4, --interval 780, tick = atris autopilot --auto --iterations=1',
+    "Keep working here for a few hours. I'll write you if something changes.",
+    'Without --yes, I only say the plan. --no-email stays quiet.',
   ];
   console.log(lines.join('\n'));
 }
 
 function planLines(args = []) {
-  const hoursIdx = args.indexOf('--hours');
-  const hours = hoursIdx !== -1 && args[hoursIdx + 1] ? args[hoursIdx + 1] : '4';
+  const list = Array.isArray(args) ? args : [];
+  const hours = spokenHours(readFlagValue(list, '--hours') || '4');
+  const next = list.includes('--no-email')
+    ? 'next: atris spaceship --yes'
+    : "I'll write you if something changes. next: atris spaceship --yes";
   return [
-    'spaceship plan (no run):',
-    `  budget: ${hours}h`,
-    '  email: on meaningful state changes (unless --no-email)',
-    '  tick: atris autopilot --auto --iterations=1',
-    'Pass --yes to start the overnight run.',
+    `${greet(personName())}I can keep working here for ${hours}.`,
+    '',
+    next,
   ];
 }
 
+function spaceshipTargetRoot(args = []) {
+  const list = Array.isArray(args) ? args : [];
+  const idx = list.indexOf('--repo');
+  const raw = idx !== -1 && list[idx + 1] && !String(list[idx + 1]).startsWith('-')
+    ? path.resolve(list[idx + 1])
+    : process.cwd();
+  return resolveWorkspaceRoot(raw);
+}
+
 function spaceship(args = []) {
   const list = Array.isArray(args) ? args : [];
   if (argsWantHelp(list) || list.includes('--help') || list.includes('-h')) {
@@ -75,6 +109,12 @@ function spaceship(args = []) {
     process.exit(2);
   }
 
+  // --yes starts the run. It is not a workspace unlock. An unbound
+  // scratch folder is not a room (same class as slack/gmail from scratch).
+  if (isUnboundScratchFolder(spaceshipTargetRoot(list))) {
+    process.exit(refuseUnboundScratch());
+  }
+
   const runArgs = list.filter((a) => a !== '--yes' && a !== '-y' && a !== '--json');
   return new Promise((resolve, reject) => {
     if (!fs.existsSync(SCRIPT)) {
@@ -99,4 +139,4 @@ function spaceship(args = []) {
   });
 }
 
-module.exports = { spaceship, SCRIPT, printUsage, planLines };
+module.exports = { spaceship, SCRIPT, printUsage, planLines, spokenHours, spaceshipTargetRoot };

package/commands/status.js

@@ -4,6 +4,13 @@ const { getLogPath, ensureLogDirectory, createLogFile } = require('../lib/journa
 const { parseTodo, getTeamActivity } = require('../lib/todo');
 const { clarify } = require('../lib/autoland');
 const { checkoutBehindMessage } = require('../lib/checkout-sync');
+const {
+  isFreshWorkspace,
+  isKeepWorkingMinute,
+  buildFirstMinute,
+  speakKeepWorkingMinute,
+  speakNothingRunning,
+} = require('../lib/first-minute');
 
 // Box drawing helpers
 const W = 64; // inner width
@@ -122,18 +129,34 @@ function parseStatusTodo(todoFile) {
   }
 }
 
+function hasLiveKeepWorkingRun(root = process.cwd()) {
+  try {
+    const { pickLiveLocalMission } = require('./mission');
+    return Boolean(pickLiveLocalMission(root));
+  } catch {
+    return false;
+  }
+}
+
 function statusAtris(isQuick = false, jsonMode = false, verbose = false) {
-  const targetDir = path.join(process.cwd(), 'atris');
+  // Fresh folder: empty talks first-talk. A file already here
+  // names that file, same as bare atris. Do not mint a room.
+  if (isFreshWorkspace()) {
+    process.exit(speakNothingRunning({ asJson: jsonMode }));
+  }
 
-  if (!fs.existsSync(targetDir)) {
-    if (jsonMode) {
-      console.log(JSON.stringify({ error: 'atris/ folder not found' }));
-      process.exit(1);
+  // Just-minted file folder, nothing running: same two lines as
+  // first-minute / the next do. A live mission still gets the board.
+  // --verbose keeps the factory dump because the operator asked for it.
+  if (!verbose && !hasLiveKeepWorkingRun()) {
+    const minute = buildFirstMinute({ root: process.cwd() });
+    if (isKeepWorkingMinute(minute)) {
+      process.exit(speakKeepWorkingMinute({ asJson: jsonMode }));
     }
-    console.log('✗ atris/ folder not found. Run "atris init" first.');
-    process.exit(1);
   }
 
+  const targetDir = path.join(process.cwd(), 'atris');
+
   // Load task board state.
   const todoFile = path.join(targetDir, 'TODO.md');
   const todo = parseStatusTodo(todoFile);

package/commands/task.js

@@ -60,7 +60,18 @@ const {
   decisionMarkerFor,
   DECISION_REFUSE_REASON,
 } = require('../lib/task-decision');
-const { buildFirstMinute, deskNextCommand, personName, pickNext, taskCommand, taskNextCommand } = require('../lib/first-minute');
+const {
+  buildFirstMinute,
+  deskNextCommand,
+  firstTalkCommand,
+  folderName,
+  personName,
+  pickNext,
+  speakFirstMinute,
+  taskCommand,
+  taskNextCommand,
+} = require('../lib/first-minute');
+const { loadContext } = require('../lib/state-detection');
 
 const DEFAULT_OWNER = process.env.ATRIS_AGENT_ID
   || process.env.USER
@@ -6166,6 +6177,23 @@ function renderTaskDesk(rows, refRows = rows) {
 }
 
 function cmdAdd(args) {
+  const root = process.cwd();
+  // Empty folder talks like bare atris. A leftover title is not a
+  // task desk. After init, a title still files.
+  if (isUninitializedTaskFolder(root)) {
+    if (wantsJson(args)) {
+      printJson({
+        ok: false,
+        action: 'none',
+        command: firstTalkCommand(folderName(root)),
+        task_id: null,
+        projection_path: null,
+        task: null,
+      });
+      return;
+    }
+    return speakFirstMinute({ root, fresh: true });
+  }
   const pos = positional(args);
   const title = pos.join(' ').trim();
   if (!title) {
@@ -6476,9 +6504,19 @@ function cmdDay(args) {
 
 function cmdFirstMinute() {
   const root = process.cwd();
+  const fresh = !fs.existsSync(path.join(root, 'atris'));
+  let context = {};
+  if (!fresh) {
+    try {
+      context = loadContext(root);
+    } catch {
+      context = {};
+    }
+  }
   const screen = buildFirstMinute({
     root,
-    fresh: !fs.existsSync(path.join(root, 'atris')),
+    fresh,
+    context,
   });
   console.log(screen.text);
 }
@@ -6809,10 +6847,12 @@ function createEndgameSeedTask(taskDb, db, seed, owner) {
 }
 
 function nextActionFromCommand(command) {
-  const match = String(command || '').trim().match(/^atris (?:task|mission) (\S+)/);
+  const text = String(command || '').trim();
+  const match = text.match(/^atris (?:task|mission) (\S+)/);
   const verb = match ? match[1] : '';
-  if (!verb || verb === 'new') return 'none';
-  return verb;
+  if (verb && verb !== 'new') return verb;
+  if (/^atris do\b/.test(text)) return 'do';
+  return 'none';
 }
 
 function cmdNextTruth(args) {
@@ -6823,9 +6863,24 @@ function cmdNextTruth(args) {
   const workspaceRoot = taskDb.workspaceRoot();
   const rows = taskDb.listTasks(db, { workspaceRoot, limit: 500 });
   const existingProj = readProjectionFile(workspaceRoot);
+  const dbHasActionable = rows.some((task) => {
+    const status = task && task.status;
+    return status === 'open' || status === 'claimed' || status === 'review';
+  });
+  const projHasActionable = Boolean(
+    existingProj
+    && Array.isArray(existingProj.tasks)
+    && existingProj.tasks.some((task) => {
+      const status = task && task.status;
+      return status === 'open' || status === 'claimed' || status === 'review';
+    }),
+  );
   let projection;
   let outPath;
-  if (rows.length === 0 && existingProj && Array.isArray(existingProj.tasks) && existingProj.tasks.length > 0) {
+  if (!dbHasActionable && projHasActionable) {
+    projection = existingProj;
+    outPath = path.resolve(path.join(workspaceRoot || '.', '.atris', 'state', 'tasks.projection.json'));
+  } else if (rows.length === 0 && existingProj && Array.isArray(existingProj.tasks) && existingProj.tasks.length > 0) {
     projection = existingProj;
     outPath = path.resolve(path.join(workspaceRoot || '.', '.atris', 'state', 'tasks.projection.json'));
   } else {
@@ -6894,9 +6949,9 @@ function cmdNext(args) {
   if (isUninitializedTaskFolder(root)) {
     if (wantsJson(args)) {
       printJson({
-        ok: true,
-        action: 'init',
-        command: 'atris init --minimal',
+        ok: false,
+        action: 'none',
+        command: firstTalkCommand(folderName(root)),
         task_id: null,
         owner: String(flag(args, '--as') || personName() || DEFAULT_OWNER),
         scope: normalizeTaskQueueScope(taskQueueScopeFromArgs(args)),
@@ -6905,9 +6960,7 @@ function cmdNext(args) {
       });
       return;
     }
-    const screen = buildFirstMinute({ root, fresh: true });
-    console.log(screen.text);
-    return;
+    return speakFirstMinute({ root, fresh: true });
   }
   if (!hasFlag(args, '--create-next')) return cmdNextTruth(args);
   const owner = flag(args, '--as') || DEFAULT_OWNER;
@@ -9779,16 +9832,17 @@ function appendRelabelArchivedJournalReceipt(workspaceRoot, { actor, count, ids
 function cmdReady(args) {
   const pos = positional(args);
   const id = pos[0];
-  if (!id) {
-    console.error('atris task ready: id required');
+  const proofFlag = flag(args, '--proof');
+  const verifyFlag = flag(args, '--verify');
+  const resultFlag = textFlag(args, ['--result']);
+  if (!id || (!proofFlag && !verifyFlag && !resultFlag)) {
+    console.log('Usage: atris task ready <id> --proof "..." --result "<sentence>"');
     process.exit(2);
   }
   // Two ways to prove: --proof "<note>" (claimed, pattern-checked) or
   // --verify "<command>" which actually RUNS the command and gates ready on exit 0.
   // If --proof names npm test, node --test, or git diff --check, this process
   // must have run that command. A sentence that names one of those is a lie.
-  const proofFlag = flag(args, '--proof');
-  const verifyFlag = flag(args, '--verify');
   const proofUrl = textFlag(args, ['--proof-url']);
   const iFetched = hasFlag(args, '--i-fetched');
   if (proofUrl && !iFetched) {

package/commands/terminal.js

@@ -2,7 +2,7 @@
  * atris terminal <business> <command...> [--timeout N]
  *
  * Run a shell command directly on a business EC2 workspace via the warm runner.
- * This is the load-bearing primitive for fast bulk ops — one bash call beats
+ * This is the load-bearing primitive for fast bulk ops: one bash call beats
  * hundreds of rate-limited individual file API calls.
  *
  * SAFETY:
@@ -27,7 +27,7 @@ const path = require('path');
 const { loadCredentials, abortOnAuthFailure } = require('../utils/auth');
 const { apiRequestJson } = require('../utils/api');
 const { loadBusinesses, saveBusinesses } = require('./business');
-const { requireAccountBound, refuseAccountGlobal } = require('../lib/account-bound');
+const { looksLikeBusinessSlug, requireAccountBound, refuseAccountGlobal } = require('../lib/account-bound');
 const { argsWantHelp, wantsJson } = require('../lib/noninteractive');
 
 function sleep(ms) {
@@ -151,8 +151,8 @@ async function terminalAtris() {
     try { return JSON.parse(fs.readFileSync(bizFile, 'utf8')).slug; } catch { return null; }
   })();
 
-  // If first arg is a single word with no shell metacharacters, it might be a slug
-  const firstLooksLikeSlug = args[0] && /^[a-z0-9-]+$/i.test(args[0]) && !args[0].includes(' ');
+  // Flags like --json match a hyphenated word regex. Require a real slug first.
+  const firstLooksLikeSlug = looksLikeBusinessSlug(args[0]);
 
   if (firstLooksLikeSlug && args.length > 1) {
     slug = args[0];
@@ -161,7 +161,7 @@ async function terminalAtris() {
     slug = cwdSlug;
     command = args.join(' ');
   } else if (firstLooksLikeSlug && args.length === 1) {
-    // First (and only) arg is a slug-shaped word — could be the slug with no command
+    // First and only arg is a slug-shaped word with no command.
     console.error('Missing command. Usage: atris terminal <business> <command>');
     process.exit(1);
   } else {