atris 3.37.0 → 3.38.0

package/commands/codex-goal.js

@@ -379,7 +379,5 @@ function codexGoalCommand(args = []) {
 
 module.exports = {
   codexGoalCommand,
-  CONFIRM_RESET_FLAG,
-  resolveStatePath,
   sqlString,
 };

package/commands/computer.js

@@ -1405,7 +1405,7 @@ function computerLocalLegacy(extraArgs = []) {
   }
 }
 
-function computerLocal(extraArgs = []) {
+function computerLocal(extraArgs = [], options = {}) {
   printLocalWordmark();
   printModeBanner('LOCAL', process.cwd(), [
     'Claude Code + Atris workspace context.',
@@ -1417,7 +1417,7 @@ function computerLocal(extraArgs = []) {
   const originalArgv = process.argv;
   process.argv = [originalArgv[0], originalArgv[1], originalArgv[2], 'claude', ...extraArgs];
   try {
-    consoleCommand();
+    consoleCommand(options);
   } finally {
     process.argv = originalArgv;
   }
@@ -4390,11 +4390,12 @@ async function runComputer(argv = process.argv.slice(3), deps = {}) {
 module.exports = {
   runComputer,
   computerSetup,
-  setupComputerChoices,
+  // `atris pack run` starts a packet as a free local computer, so it needs the
+  // local starter and the business-binding check as seams, not copies.
+  computerLocal,
+  readBusinessBinding,
   formatEngineSeats,
   buildComputerCard,
-  renderComputerCard,
-  renderComputerCardMarkdown,
   extractAttachedWorkspaceMismatch,
   contextForAttachedWorkspaceMismatch,
   printRecruitingLocalSyncOutcome,

package/commands/console.js

@@ -7,10 +7,40 @@ const { resolveClaudeRunnerBin } = require('../lib/runner-command');
 
 // ── Context Gathering ──────────────────────────────────────────────
 
+// Atris content lives in two shapes on disk, and the console has to read both.
+//
+//   workspace: <dir>/atris/{skills,team,TODO.md,...}
+//     The normal repo shape. A project keeps its Atris brain in a subfolder so
+//     it does not collide with the project's own files. This is the common case.
+//
+//   packet:    <dir>/{pack.json,skills,team,docs,...}
+//     A packet built in root mode (pack.js exports with prefix '' when the
+//     source dir has pack.json at its root — this is how the shipped packs are
+//     built and what the web /packs/<slug>/download route serves). `pack
+//     install` preserves that flat layout, so the packet folder IS the atris
+//     root; there is no nested atris/ to find.
+//
+// Nested wins when both exist: never change what an existing workspace loads.
+// Returns the directory that actually holds the atris content, or null.
+function resolveAtrisRoot(workspaceDir) {
+  const nested = path.join(workspaceDir, 'atris');
+  try {
+    if (fs.statSync(nested).isDirectory()) return nested;
+  } catch {}
+  const manifest = path.join(workspaceDir, 'pack.json');
+  try {
+    if (!fs.statSync(manifest).isFile()) return null;
+    JSON.parse(fs.readFileSync(manifest, 'utf8'));
+    return workspaceDir;
+  } catch {}
+  return null;
+}
+
 function gatherAtrisContext(workspaceDir) {
-  const atrisDir = path.join(workspaceDir, 'atris');
+  const atrisDir = resolveAtrisRoot(workspaceDir);
   const ctx = {
-    hasAtris: fs.existsSync(atrisDir),
+    hasAtris: Boolean(atrisDir),
+    atrisRoot: atrisDir,
     skills: [],
     teamMembers: [],
     backlogCount: 0,
@@ -119,7 +149,8 @@ function buildSystemPrompt(ctx) {
   if (ctx.teamMembers.length > 0) {
     lines.push('## Team Members');
     lines.push(`Available: ${ctx.teamMembers.join(', ')}`);
-    lines.push('Each has a MEMBER.md in atris/team/<name>/ defining their role.');
+    const teamRoot = ctx.atrisRoot ? path.join(ctx.atrisRoot, 'team') : 'atris/team';
+    lines.push(`Each has a MEMBER.md in ${teamRoot}/<name>/ defining their role.`);
     lines.push('');
   }
 
@@ -135,7 +166,8 @@ function buildSystemPrompt(ctx) {
 
   if (ctx.backlogCount > 0) {
     lines.push(`## Current Work`);
-    lines.push(`${ctx.backlogCount} task${ctx.backlogCount > 1 ? 's' : ''} in backlog. Check atris/TODO.md for details.`);
+    const todoPath = ctx.atrisRoot ? path.join(ctx.atrisRoot, 'TODO.md') : 'atris/TODO.md';
+    lines.push(`${ctx.backlogCount} task${ctx.backlogCount > 1 ? 's' : ''} in backlog. Check ${todoPath} for details.`);
     lines.push('');
   }
 
@@ -280,10 +312,11 @@ function checkAuth(backend) {
 
 // ── Launch ──────────────────────────────────────────────────────────
 
-function launchClaude(systemPrompt, extraArgs) {
+function launchClaude(systemPrompt, extraArgs, options = {}) {
+  const skipPermissions = options.skipPermissions !== false;
   const runnerBin = resolveClaudeRunnerBin();
   const args = [
-    '--dangerously-skip-permissions',
+    ...(skipPermissions ? ['--dangerously-skip-permissions'] : []),
     '--append-system-prompt', systemPrompt,
     ...extraArgs,
   ];
@@ -342,7 +375,11 @@ function launchCodex(systemPrompt, extraArgs) {
 
 // ── Main ────────────────────────────────────────────────────────────
 
-function consoleCommand() {
+// skipPermissions defaults to true: `atris console` runs on a workspace you
+// wrote. Callers that launch an agent inside content someone else authored
+// (`atris pack run`) pass false so permission prompts stay on.
+function consoleCommand(options = {}) {
+  const skipPermissions = options.skipPermissions !== false;
   const args = process.argv.slice(3);
   let requested = args[0];
 
@@ -385,7 +422,7 @@ function consoleCommand() {
 
     // Launch
     if (backend === 'claude') {
-      launchClaude(systemPrompt, extraArgs);
+      launchClaude(systemPrompt, extraArgs, { skipPermissions });
     } else {
       launchCodex(systemPrompt, extraArgs);
     }
@@ -399,4 +436,4 @@ function consoleCommand() {
   }
 }
 
-module.exports = { consoleCommand, gatherAtrisContext, buildSystemPrompt };
+module.exports = { consoleCommand, gatherAtrisContext, buildSystemPrompt, resolveAtrisRoot, launchClaude };

package/commands/deck.js

@@ -141,6 +141,23 @@ function readSpec(specPath) {
   return JSON.parse(fs.readFileSync(specPath, 'utf8'));
 }
 
+// Pluralize a count + noun ("1 error", "2 errors").
+function countLabel(n, word) {
+  return `${n} ${word}${n === 1 ? '' : 's'}`;
+}
+
+// True when the args carry an explicit help flag.
+function wantsHelp(argv) {
+  return argv.includes('--help') || argv.includes('-h');
+}
+
+// One-line lint tally with correct singular/plural nouns.
+function lintSummary(findings) {
+  const errs = findings.filter((f) => f.severity === 'error').length;
+  const warns = findings.filter((f) => f.severity === 'warn').length;
+  return `${countLabel(errs, 'error')}, ${countLabel(warns, 'warning')}`;
+}
+
 function printLint(findings) {
   if (!findings.length) {
     console.log('\n  ✓ spec lint clean\n');
@@ -369,15 +386,13 @@ async function run(argv) {
     const findings = checkSpec(spec, lintSpec);
     if (out) {
       fs.writeFileSync(out, `${JSON.stringify(spec, null, 2)}\n`);
-      console.error(`\n  ✓ composed ${spec.slides.length} slides (${spec.theme}) -> ${out}`);
+      console.error(`\n  ✓ composed ${countLabel(spec.slides.length, 'slide')} (${spec.theme}) -> ${out}`);
       printLint(findings);
       console.error(`  next: atris deck build ${out} --review\n`);
     } else {
       // stdout stays clean JSON for piping; lint goes to stderr
       console.log(JSON.stringify(spec, null, 2));
-      const errs = findings.filter((f) => f.severity === 'error').length;
-      const warns = findings.filter((f) => f.severity === 'warn').length;
-      console.error(`  composed ${spec.slides.length} slides (${spec.theme}) · lint: ${errs} errors, ${warns} warnings`);
+      console.error(`  composed ${countLabel(spec.slides.length, 'slide')} (${spec.theme}) · lint: ${lintSummary(findings)}`);
     }
     return hasErrors(findings) ? 1 : 0;
   }
@@ -385,8 +400,11 @@ async function run(argv) {
   if (sub === 'lint') {
     const specPath = argv.slice(1).find((a) => !a.startsWith('-'));
     if (!specPath) {
-      console.error('  usage: atris deck lint <spec.json>');
-      return 2;
+      // Explicit -h/--help is a help request (stdout, exit 0); a genuinely
+      // missing spec path is a usage error (stderr, exit 2).
+      const help = wantsHelp(argv);
+      console[help ? 'log' : 'error']('  usage: atris deck lint <spec.json>');
+      return help ? 0 : 2;
     }
     let spec;
     try { spec = readSpec(specPath); }
@@ -488,8 +506,9 @@ async function run(argv) {
     }
     const specPath = specPaths[0];
     if (!specPath) {
-      console.error('  usage: atris deck build <spec.json> [<spec2.json> ...] [--title T] [--theme x] [--review]');
-      return 2;
+      const help = wantsHelp(argv);
+      console[help ? 'log' : 'error']('  usage: atris deck build <spec.json> [<spec2.json> ...] [--title T] [--theme x] [--review]');
+      return help ? 0 : 2;
     }
     let spec;
     try { spec = readSpec(specPath); }
@@ -576,6 +595,8 @@ module.exports = {
   lintSpec,
   validateSpec,
   checkSpec,
+  countLabel,
+  lintSummary,
   planBatch,
   publishDeck,
   videoToDeck,

package/commands/dream.js

@@ -353,13 +353,6 @@ async function dreamCommand(args = [], root = process.cwd(), options = {}) {
 }
 
 module.exports = {
-  DREAM_TIMEOUT_MS,
   dreamsPath,
-  collectDreamMaterial,
-  buildDreamPrompt,
-  parseDreamCards,
-  dreamModels,
-  defaultDreamRunner,
-  runDream,
   dreamCommand,
 };

package/commands/drill.js

@@ -365,7 +365,6 @@ async function drillCommand(args = []) {
 
 module.exports = {
   COAUTHOR,
-  VERIFY_COMMAND,
   drillCommand,
   runDrill,
 };

package/commands/engine.js

@@ -33,6 +33,7 @@ const {
   engineRegistryView,
   readEngineRegistry,
   resolveEngineForRole,
+  resolveEngineForRoleRanked,
   setEngineHealth,
 } = require('../lib/engine-registry');
 const { FLEET_CAPABLE, runDispatchFlight } = require('../lib/fleet');
@@ -932,22 +933,26 @@ function runResolveCommand(args, root) {
     else console.error(message);
     return 2;
   }
-  let engine;
+  let picked;
   try {
-    engine = resolveEngineForRole(role, root);
+    picked = resolveEngineForRoleRanked(role, root);
   } catch (err) {
     if (json) console.log(JSON.stringify({ ok: false, error: err.message }, null, 2));
     else console.error(err.message);
     return 2;
   }
+  const engine = picked.engine;
   if (!engine) {
     const message = `No ready installed engine can fill role "${role}".`;
-    if (json) console.log(JSON.stringify({ ok: false, role, error: message }, null, 2));
+    if (json) console.log(JSON.stringify({ ok: false, role, error: message, won_reason: picked.reason }, null, 2));
     else console.error(message);
     return 1;
   }
-  if (json) console.log(JSON.stringify(engine, null, 2));
-  else console.log(engine.id);
+  if (json) console.log(JSON.stringify({ ...engine, won_reason: picked.reason }, null, 2));
+  else {
+    console.error(picked.reason);
+    console.log(engine.id);
+  }
   return 0;
 }
 
@@ -1294,36 +1299,23 @@ module.exports = {
   resolveDefaultEngine,
   canonicalEngineName,
   readSavedEngine,
-  setEngine,
-  resetEngine,
   roster,
-  registryPayload,
   engineRegistryFile,
   readEngineRegistry,
   resolveEngineForRole,
   setEngineHealth,
-  probeEngine,
-  runEngineTest,
   parseDispatchArgs,
   runDispatchCommand,
   ENGINE_LOGIN_MANIFESTS,
-  MAX_ENGINE_LOGIN_FILE_BYTES,
   expandHomePath,
   normalizeLoginProvider,
   normalizeEngineLoginSeat,
   validEngineLoginSeat,
   engineLoginSeatError,
-  detectedEmailFromContent,
-  readEngineLoginFiles,
   parseEngineLoginArgs,
-  parseEngineSeedArgs,
-  redactBackendResponse,
-  buildEngineLoginPayload,
-  listEngineLogins,
   listEngineSeats,
   readyCheckEngineLogin,
   formatEngineSeats,
-  runEngineSeatsCommand,
   runEngineDeviceLoginCommand,
   runEngineLoginCommand,
   runEngineSeedCommand,

package/commands/experiments.js

@@ -588,8 +588,4 @@ function experimentsCommand(subcommand, ...args) {
 module.exports = {
   experimentsCommand,
   ensureExperimentsFramework,
-  buildBenchmarkArtifact,
-  parseRunOptions,
-  experimentsDaily,
-  experimentsQueue,
 };

package/commands/fleet-report.js

@@ -79,6 +79,16 @@ async function writeReportToComputer(token, businessId, workspaceId, report) {
   return remotePath;
 }
 
+// A missing scoreboard field must never reach the owner as "$NaN" or
+// "$undefined"; coerce every number to 0 before it renders.
+function formatScoreboardPnl(board) {
+  if (!board) return '';
+  const mrr = Number(board.revenue_mrr_usd) || 0;
+  const cost = (Number(board.compute_cost_usd) || 0) + (Number(board.ec2_cost_usd) || 0);
+  const profit = Number(board.profit_daily_usd) || 0;
+  return ` | mrr $${mrr} cost $${cost.toFixed(2)}/d profit $${profit}/d`;
+}
+
 async function deliverToBusiness(token, biz, { wake, dryRun }) {
   const label = biz.slug || biz.name || biz.id;
   const status = await computerStatus(token, biz.id);
@@ -97,9 +107,7 @@ async function deliverToBusiness(token, biz, { wake, dryRun }) {
 
   const report = await fetchDailyReport(token, biz.id);
   const board = report.scoreboard || null;
-  const pnl = board
-    ? ` | mrr $${board.revenue_mrr_usd} cost $${(board.compute_cost_usd + (board.ec2_cost_usd || 0)).toFixed(2)}/d profit $${board.profit_daily_usd}/d`
-    : '';
+  const pnl = formatScoreboardPnl(board);
   if (dryRun) {
     console.log(`  ${label}: dry-run, report ${String(report.markdown || '').length} chars${pnl}`);
     return { business: label, delivered: false, reason: 'dry-run', scoreboard: board };
@@ -203,4 +211,4 @@ async function fleetReport() {
   process.exitCode = delivered > 0 || dryRun || results.every((r) => r.reason === 'asleep') ? 0 : 1;
 }
 
-module.exports = { fleetReport };
+module.exports = { fleetReport, formatScoreboardPnl };

package/commands/game.js

@@ -0,0 +1,261 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+const DEFAULT_WIDTH = 80;
+const MIN_WIDTH = 20;
+const MAX_WIDTH = 120;
+const STORYLINE_SLUG_PATTERN = /^[a-z0-9-]+$/;
+
+function isValidStorylineSlug(slug) {
+  return typeof slug === 'string' && STORYLINE_SLUG_PATTERN.test(slug);
+}
+
+function parseGameArgs(args = []) {
+  let storyline = null;
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === '--storyline') {
+      const value = args[index + 1];
+      if (!value || value.startsWith('--')) {
+        return { error: 'missing storyline slug' };
+      }
+      if (storyline) return { error: 'choose one storyline' };
+      storyline = value;
+      index += 1;
+      continue;
+    }
+    if (arg.startsWith('--')) return { error: `unknown game option: ${arg}` };
+    if (storyline) return { error: 'choose one storyline' };
+    storyline = arg;
+  }
+
+  return {
+    storyline,
+    publisherArgs: storyline ? ['--json', '--storyline', storyline] : ['--json'],
+  };
+}
+
+function availableStorylines(workspaceRoot) {
+  const directory = path.join(workspaceRoot, 'atris', 'storylines');
+  try {
+    return fs.readdirSync(directory, { withFileTypes: true })
+      .filter(entry => entry.isFile() && entry.name.endsWith('.md'))
+      .map(entry => path.basename(entry.name, '.md'))
+      .filter(slug => slug !== 'resume-log')
+      .sort();
+  } catch {
+    return [];
+  }
+}
+
+function publisherSupportsStoryline(script) {
+  try {
+    return fs.readFileSync(script, 'utf8').includes('--storyline');
+  } catch {
+    return false;
+  }
+}
+
+function clean(value, fallback = '') {
+  const text = String(value == null ? '' : value)
+    .replace(/[—–]/g, '-')
+    .replace(/\s+/g, ' ')
+    .trim();
+  return text || fallback;
+}
+
+function clip(value, width) {
+  const chars = Array.from(clean(value));
+  if (chars.length <= width) return chars.join('');
+  if (width <= 3) return chars.slice(0, width).join('');
+  return `${chars.slice(0, width - 3).join('').trimEnd()}...`;
+}
+
+function pad(value, width) {
+  const text = clip(value, width);
+  return `${text}${' '.repeat(Math.max(0, width - Array.from(text).length))}`;
+}
+
+function dashboardWidth(opts) {
+  const requested = Number(opts && opts.width);
+  if (!Number.isFinite(requested)) return DEFAULT_WIDTH;
+  return Math.max(MIN_WIDTH, Math.min(MAX_WIDTH, Math.trunc(requested)));
+}
+
+function styles(enabled) {
+  const wrap = code => value => (
+    enabled ? `\x1b[${code}m${value}\x1b[0m` : String(value)
+  );
+  return {
+    bold: wrap('1'),
+    dim: wrap('2'),
+    green: wrap('32'),
+    yellow: wrap('33'),
+    cyan: wrap('36'),
+  };
+}
+
+function chapterLine(chapter, width, style) {
+  const state = clean(chapter && chapter.state, 'locked').toLowerCase();
+  const current = state === 'current';
+  const done = state === 'complete' || state === 'done';
+  const marker = current ? '[NOW ]' : done ? '[DONE]' : '[LOCK]';
+  const number = chapter && chapter.n != null ? `${chapter.n}.` : '';
+  const location = current ? '  YOU ARE HERE' : '';
+  const line = clip(`${marker} ${number} ${clean(chapter && chapter.title, 'Untitled chapter')}${location}`, width);
+  if (current) return style.yellow(style.bold(line));
+  if (done) return style.green(line);
+  return style.dim(line);
+}
+
+function missionBox(mission, width, style) {
+  const innerWidth = width - 2;
+  const contentWidth = width - 4;
+  const heading = ' CURRENT MISSION ';
+  const top = heading.length <= innerWidth
+    ? `╔${heading}${'═'.repeat(innerWidth - heading.length)}╗`
+    : `╔${'═'.repeat(innerWidth)}╗`;
+  const row = value => `║ ${pad(value, contentWidth)} ║`;
+  const bottom = `╚${'═'.repeat(innerWidth)}╝`;
+  const title = clean(mission && mission.title, 'No current mission');
+  const status = clean(mission && mission.status, 'unavailable').toUpperCase();
+  return [
+    style.cyan(style.bold(top)),
+    style.bold(row(title)),
+    row(`STATUS: ${status}`),
+    style.cyan(style.bold(bottom)),
+  ];
+}
+
+/**
+ * Render an atris.game_state.v1 payload without reading process or filesystem state.
+ * Callers opt into ANSI with opts.color and provide their terminal width via opts.width.
+ */
+function renderGameDashboard(payload, opts = {}) {
+  const state = payload && typeof payload === 'object' ? payload : {};
+  const storyline = state.storyline && typeof state.storyline === 'object'
+    ? state.storyline
+    : null;
+  const missions = state.missions && typeof state.missions === 'object'
+    ? state.missions
+    : {};
+  const active = Array.isArray(missions.active) ? missions.active.slice(0, 3) : [];
+  const recentComplete = Array.isArray(missions.recent_complete)
+    ? missions.recent_complete.length
+    : Number(missions.recent_complete) || 0;
+  const width = dashboardWidth(opts);
+  const style = styles(opts.color === true);
+  const title = clean(storyline && storyline.name, 'No storyline loaded');
+  const destination = clean(storyline && storyline.destination, 'No destination loaded');
+  const chapters = Array.isArray(storyline && storyline.chapters)
+    ? storyline.chapters.slice(0, 7)
+    : [];
+  const streak = storyline && storyline.streak && typeof storyline.streak === 'object'
+    ? storyline.streak
+    : {};
+  const streakCurrent = Number.isFinite(Number(streak.current)) ? Number(streak.current) : 0;
+  const streakTarget = Number.isFinite(Number(streak.target)) ? Number(streak.target) : 0;
+  const streakLabel = clean(streak.label, 'mission streak');
+  const lines = [];
+
+  lines.push(style.cyan(style.bold(clip(title, width))));
+  lines.push(style.dim(clip(`DESTINATION: ${destination}`, width)));
+  lines.push('');
+  lines.push(style.bold('CHAPTER RAIL'));
+  if (chapters.length) {
+    for (const chapter of chapters) lines.push(chapterLine(chapter, width, style));
+  } else {
+    lines.push(style.dim(clip('[LOCK] No chapters loaded', width)));
+  }
+
+  lines.push('');
+  lines.push(...missionBox(storyline && storyline.mission, width, style));
+  lines.push('');
+  lines.push(style.yellow(style.bold(clip(`STREAK: ${streakCurrent} / ${streakTarget} | ${streakLabel}`, width))));
+  lines.push('');
+  lines.push(style.bold('LIVE MISSIONS'));
+  if (active.length) {
+    for (const mission of active) {
+      const id = mission && mission.id != null ? `#${mission.id}` : '#?';
+      lines.push(style.bold(clip(`${id} ${clean(mission && mission.title, 'Untitled mission')}`, width)));
+      lines.push(style.dim(clip(`  owner: ${clean(mission && mission.owner, 'unassigned')}`, width)));
+      lines.push(clip(`  next: ${clean(mission && mission.next, 'No next action recorded')}`, width));
+    }
+  } else {
+    lines.push(style.dim(clip('No active missions.', width)));
+  }
+  lines.push(clip(`RECENT COMPLETES: ${recentComplete}`, width));
+  lines.push('');
+  lines.push(style.cyan(style.bold(clip(`NEXT MOVE: ${clean(active[0] && active[0].next, 'No active mission')}`, width))));
+
+  return lines.join('\n');
+}
+
+function loadGameState(workspaceRoot = process.cwd(), publisherArgs = ['--json']) {
+  const script = path.join(workspaceRoot, 'scripts', 'game_state_sync.py');
+  const python = path.join(workspaceRoot, 'venv', 'bin', 'python');
+  if (!fs.existsSync(script) || !fs.existsSync(python)) return null;
+
+  try {
+    const stdout = execFileSync(python, [script, ...publisherArgs], {
+      cwd: workspaceRoot,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      maxBuffer: 4 * 1024 * 1024,
+    });
+    const payload = JSON.parse(stdout.trim());
+    return payload && typeof payload === 'object' ? payload : null;
+  } catch {
+    return null;
+  }
+}
+
+async function gameCommand(args = [], opts = {}) {
+  const parsed = parseGameArgs(args);
+  if (parsed.error) {
+    console.error(parsed.error);
+    return 1;
+  }
+  if (parsed.storyline && !isValidStorylineSlug(parsed.storyline)) {
+    console.error(`invalid storyline slug: ${parsed.storyline}`);
+    return 1;
+  }
+
+  const workspaceRoot = process.cwd();
+  if (parsed.storyline) {
+    const storylines = availableStorylines(workspaceRoot);
+    if (!storylines.includes(parsed.storyline)) {
+      console.error(`storyline not found: ${parsed.storyline}. available: ${storylines.join(', ') || 'none'}`);
+      return 1;
+    }
+  }
+
+  const script = path.join(workspaceRoot, 'scripts', 'game_state_sync.py');
+  const publisherArgs = parsed.storyline && publisherSupportsStoryline(script)
+    ? parsed.publisherArgs
+    : ['--json'];
+  const payload = loadGameState(workspaceRoot, publisherArgs);
+  if (!payload) {
+    if (!opts.silentMissing) {
+      console.log('no game state in this workspace (needs atris/storylines/)');
+    }
+    return false;
+  }
+
+  console.log(renderGameDashboard(payload, {
+    color: Boolean(process.stdout.isTTY) && !process.env.NO_COLOR,
+    width: process.stdout.columns || DEFAULT_WIDTH,
+  }));
+  return true;
+}
+
+module.exports = {
+  renderGameDashboard,
+  isValidStorylineSlug,
+  parseGameArgs,
+  gameCommand,
+};

package/commands/gm.js

@@ -658,6 +658,16 @@ async function gmCommand(...args) {
     return memberCommand('wake', member, ...passthrough);
   }
 
+  if (!hasFlag(args, '--json') && !hasFlag(args, '--watch')) {
+    try {
+      const { gameCommand } = require('./game');
+      const dashboardShown = await gameCommand([], { silentMissing: true });
+      if (dashboardShown) console.log('');
+    } catch {
+      // The dashboard is an optional opening screen and must never block GM mode.
+    }
+  }
+
   const state = gmState(args);
   if (hasFlag(args, '--json')) {
     console.log(JSON.stringify(state, null, 2));
@@ -671,6 +681,4 @@ async function gmCommand(...args) {
 
 module.exports = {
   gmCommand,
-  gmState,
-  gmWatchSnapshot,
 };

package/commands/goal.js

@@ -237,11 +237,5 @@ function run(args = [], context = {}) {
 }
 
 module.exports = {
-  SCOREBOARD_FILE,
-  buildGoalView,
-  readScoreboard,
-  renderGoalView,
   run,
-  scoreboardPath,
-  writeScoreboard,
 };

package/commands/harvest.js

@@ -174,6 +174,5 @@ function harvestCommand(args = []) {
 }
 
 module.exports = {
-  harvestActions,
   harvestCommand,
 };