atris 3.61.0 → 3.63.0

package/commands/one-lap.js

@@ -7,11 +7,13 @@ const { spawnSync } = require('child_process');
 const { freezeMissionVerifier, listMissions, markMissionReviewReady } = require('./mission');
 const { readWishes } = require('../lib/wish-store');
 const {
+  engineReadyAt,
   engineRegistryView,
   resolveEngineForRole,
   resolveEngineForRoleRanked,
   resolveRegisteredEngine,
   rosterPinFor,
+  ROSTER_PIN_FIELDS,
   rosterDecided,
 } = require('../lib/engine-registry');
 const { parseVerifyCommand } = require('../lib/auto-accept-certified');
@@ -156,7 +158,7 @@ function readyExecutor(root, preferred = '') {
   if (preferred) {
     const selected = resolveRegisteredEngine(preferred, root);
     if (!selected.roles.includes('executor')) throw new Error(`engine ${selected.id} is not an executor`);
-    if (!selected.health || selected.health.status !== 'ready') throw new Error(`engine ${selected.id} is not ready`);
+    if (!engineReadyAt(selected)) throw new Error(`engine ${selected.id} is not ready`);
     if (!fleet.FLEET_CAPABLE.includes(selected.id)) throw new Error(`engine ${selected.id} cannot build headlessly`);
     const pin = rosterPinFor('executor', selected.id, root);
     return Object.keys(pin).length ? { ...selected, ...pin } : selected;
@@ -165,7 +167,7 @@ function readyExecutor(root, preferred = '') {
   if (routed && fleet.FLEET_CAPABLE.includes(routed.id)) return routed;
   return engineRegistryView(root)
     .filter((engine) => engine.roles.includes('executor'))
-    .filter((engine) => engine.health && engine.health.status === 'ready')
+    .filter((engine) => engineReadyAt(engine))
     .filter((engine) => fleet.FLEET_CAPABLE.includes(engine.id))
     .sort((a, b) => Number(a.fallback_order) - Number(b.fallback_order))[0] || null;
 }
@@ -178,7 +180,7 @@ function readyValidators(root, preferred = '', exclude = '') {
     ? rosterRanked.ranked.map((engine) => engine.id)
     : [];
   const pinned = fromRoster && rosterRanked.engine
-    && (rosterRanked.engine.roster_model || rosterRanked.engine.roster_effort || rosterRanked.engine.roster_max_seconds)
+    && (rosterRanked.engine.roster_model || rosterRanked.engine.roster_effort || rosterRanked.engine.roster_max_seconds || rosterRanked.engine.roster_prep)
     ? rosterRanked.engine
     : null;
   // A roster pick can name an engine that reviews only when picked (codex),
@@ -196,7 +198,7 @@ function readyValidators(root, preferred = '', exclude = '') {
         || String(a.id).localeCompare(String(b.id));
     })
     .map((engine) => (pinned && engine.id === pinned.id ? { ...engine, ...pinFields(pinned) } : engine));
-  const ready = candidates.filter((engine) => engine.health && engine.health.status === 'ready');
+  const ready = candidates.filter((engine) => engineReadyAt(engine));
   // Route-time determinism: which validator binaries exist on this machine
   // must not change the lap's route. When none are ready, dispatch with the
   // policy-ordered distinct validators; the flight still enforces judge !=
@@ -207,24 +209,25 @@ function readyValidators(root, preferred = '', exclude = '') {
 
 function pinFields(engine) {
   const pin = {};
-  for (const field of ['roster_model', 'roster_effort', 'roster_max_seconds']) {
+  for (const field of ROSTER_PIN_FIELDS) {
     if (engine && engine[field]) pin[field] = engine[field];
   }
   return pin;
 }
 
-// The roster's pins ride into the flight: the builder's model, effort, and
-// time cap for the builder, and each reviewer's for that reviewer only. A
-// reviewer with only a model keeps the plain model string.
+// The roster's pins ride into the flight: the builder's model, effort, time
+// cap, and prep job for the builder, and each reviewer's for that reviewer
+// only. A reviewer with only a model keeps the plain model string.
 function lapModelPins(executor, validators = []) {
   const validatorModels = {};
   for (const engine of validators) {
     if (!engine) continue;
-    if (engine.roster_effort || engine.roster_max_seconds) {
+    if (engine.roster_effort || engine.roster_max_seconds || engine.roster_prep) {
       validatorModels[engine.id] = {
         model: engine.roster_model || '',
         effort: engine.roster_effort || '',
         max_seconds: engine.roster_max_seconds || 0,
+        ...(engine.roster_prep ? { prep: engine.roster_prep } : {}),
       };
     } else if (engine.roster_model) {
       validatorModels[engine.id] = engine.roster_model;
@@ -234,6 +237,7 @@ function lapModelPins(executor, validators = []) {
     model: executor && executor.roster_model || '',
     ...(executor && executor.roster_effort ? { effort: executor.roster_effort } : {}),
     ...(executor && executor.roster_max_seconds ? { maxSeconds: executor.roster_max_seconds } : {}),
+    ...(executor && executor.roster_prep ? { prep: executor.roster_prep } : {}),
     validatorModels: Object.keys(validatorModels).length ? validatorModels : null,
   };
 }
@@ -710,7 +714,7 @@ async function runOneLap(ask, options = {}) {
       ...lapModelPins(executor, validators),
       actor: mission.owner || 'mission-lead',
       installedEngines: engineRegistryView(root)
-        .filter((entry) => entry.health && entry.health.status === 'ready')
+        .filter((entry) => engineReadyAt(entry))
         .filter((entry) => fleet.FLEET_CAPABLE.includes(entry.id))
         .map((entry) => entry.id),
       ownCli: runCli,

package/commands/stream.js

@@ -6,7 +6,7 @@ const { hasFlag, readFlag } = require('../lib/arg-parser');
 const { isNonInteractive } = require('../lib/noninteractive');
 const escapeRegExp = require('../lib/escape-regexp');
 const { runGit: spawnGit } = require('../lib/git-spawn');
-const { collectBoard } = require('./land');
+const { clearBoardMemo, sharedBoard } = require('./land');
 const { listWorktrees } = require('./worktree');
 
 const DEFAULT_INTERVAL_MS = 3000;
@@ -15,6 +15,11 @@ const MAX_SUMMARY = 180;
 const ACTIVE_MISSION_STATES = new Set(['planning', 'active', 'running', 'ready']);
 const ACTIVE_TASK_STATES = new Set(['claimed', 'do', 'doing', 'in_progress', 'review']);
 
+// One stable default runner so per-process memos can key on it.
+function defaultRunGit(root, args) {
+  return spawnGit(args, { cwd: root, check: false });
+}
+
 function defaultDeps() {
   return {
     existsSync: fs.existsSync,
@@ -22,7 +27,7 @@ function defaultDeps() {
     readdirSync: fs.readdirSync,
     statSync: fs.statSync,
     watch: fs.watch,
-    runGit: (root, args) => spawnGit(args, { cwd: root, check: false }),
+    runGit: defaultRunGit,
     now: () => Date.now(),
   };
 }
@@ -540,26 +545,48 @@ function collectWorkspaceRoots(root, deps) {
   return [...out.values()];
 }
 
+// Owner and task come from one `git config` read per root, shared for a few
+// seconds across the snapshot and the event scan of the same command.
+const WORKTREE_CONFIG_MAX_AGE_MS = 10000;
+const worktreeConfigMemo = new WeakMap();
+
+function worktreeConfig(root, deps) {
+  const key = typeof deps.runGit === 'function' ? deps.runGit : null;
+  let byRoot = key ? worktreeConfigMemo.get(key) : null;
+  if (key && !byRoot) {
+    byRoot = new Map();
+    worktreeConfigMemo.set(key, byRoot);
+  }
+  const hit = byRoot && byRoot.get(root);
+  if (hit && Date.now() - hit.at < WORKTREE_CONFIG_MAX_AGE_MS) return hit;
+  const found = { owner: '', task: '', at: Date.now() };
+  const result = runGit(root, ['config', '--get-regexp', '^branch\\..*\\.atris-(owner|task)$'], deps);
+  if (result.status === 0) {
+    for (const line of String(result.stdout || '').split(/\r?\n/).filter(Boolean)) {
+      const [name, ...rest] = line.split(/\s+/);
+      const value = rest.join(' ');
+      if (!found.owner && /\.atris-owner$/i.test(name)) found.owner = value;
+      if (!found.task && /\.atris-task$/i.test(name)) found.task = value;
+    }
+  }
+  if (byRoot) byRoot.set(root, found);
+  return found;
+}
+
+function clearWorktreeConfigMemo(deps) {
+  if (deps && typeof deps.runGit === 'function') worktreeConfigMemo.delete(deps.runGit);
+}
+
 function worktreeOwner(root, deps) {
   const sidecar = readJson(statePaths(root).sidecar, deps, null);
   if (sidecar) return sidecar.owner || sidecar.member || sidecar.agent || '';
-  const result = runGit(root, ['config', '--get-regexp', '^branch\\..*\\.atris-owner$'], deps);
-  if (result.status === 0) {
-    const line = String(result.stdout || '').split(/\r?\n/).find(Boolean);
-    if (line) return line.split(/\s+/).slice(1).join(' ');
-  }
-  return '';
+  return worktreeConfig(root, deps).owner;
 }
 
 function worktreeTask(root, deps) {
   const sidecar = readJson(statePaths(root).sidecar, deps, null);
   if (sidecar && sidecar.task) return sidecar.task;
-  const result = runGit(root, ['config', '--get-regexp', '^branch\\..*\\.atris-task$'], deps);
-  if (result.status === 0) {
-    const line = String(result.stdout || '').split(/\r?\n/).find(Boolean);
-    if (line) return line.split(/\s+/).slice(1).join(' ');
-  }
-  return '';
+  return worktreeConfig(root, deps).task;
 }
 
 function collectWorktreeActivityEvents(root, deps, events) {
@@ -584,7 +611,7 @@ function collectWorktreeActivityEvents(root, deps, events) {
 
 function collectLandingStateEvent(root, deps, events, nowMs) {
   try {
-    const board = collectBoard(root);
+    const board = sharedBoard(root);
     const summary = board && board.summary || {};
     const active = Number(summary.active || 0);
     const due = Number(summary.due || 0);
@@ -610,7 +637,7 @@ function collectLandingStateEvent(root, deps, events, nowMs) {
   }
 }
 
-function collectStreamEvents({ root = process.cwd(), sinceMs = 0, agent = '', nowMs = Date.now(), deps = defaultDeps() } = {}) {
+function collectStreamEvents({ root = process.cwd(), sinceMs = 0, agent = '', nowMs = Date.now(), deps = defaultDeps(), skipLanding = false } = {}) {
   const allDeps = { ...defaultDeps(), ...deps };
   const events = [];
   const roots = collectWorkspaceRoots(root, allDeps);
@@ -622,7 +649,7 @@ function collectStreamEvents({ root = process.cwd(), sinceMs = 0, agent = '', no
     collectScorecardEvents(item.root, allDeps, events);
   }
   collectWorktreeActivityEvents(root, allDeps, events);
-  collectLandingStateEvent(root, allDeps, events, nowMs);
+  if (!skipLanding) collectLandingStateEvent(root, allDeps, events, nowMs);
   const wantedAgent = agent ? sanitizeAgent(agent).toLowerCase() : '';
   const byKey = new Map();
   for (const event of events) {
@@ -648,7 +675,9 @@ function waitingOnOperator(tasks) {
   });
 }
 
-function collectSnapshot({ root = process.cwd(), deps = defaultDeps() } = {}) {
+// skipLanding: callers that never show the landing wait (the team roster)
+// skip the landing board, the most expensive git work here.
+function collectSnapshot({ root = process.cwd(), deps = defaultDeps(), skipLanding = false } = {}) {
   const allDeps = { ...defaultDeps(), ...deps };
   const active = new Map();
   const waiting = [];
@@ -668,10 +697,13 @@ function collectSnapshot({ root = process.cwd(), deps = defaultDeps() } = {}) {
     if (owner) active.set(sanitizeAgent(owner), clip(worktreeTask(item.root, allDeps) || 'worktree changes', 90));
   }
   let landingWait = 0;
-  try {
-    const board = collectBoard(root);
-    landingWait = Number(board?.summary?.due || 0);
-  } catch {}
+  if (!skipLanding) {
+    try {
+      // Same options as the landing-state event so both share one board.
+      const board = sharedBoard(root);
+      landingWait = Number(board?.summary?.due || 0);
+    } catch {}
+  }
   const activeRows = [...active.entries()];
   const lines = [];
   lines.push(`Team stream: ${activeRows.length} active agent${activeRows.length === 1 ? '' : 's'}.`);
@@ -838,6 +870,8 @@ function streamCommand(args = [], deps = defaultDeps()) {
     if (closed || polling) return;
     polling = true;
     try {
+      clearBoardMemo();
+      clearWorktreeConfigMemo(allDeps);
       const fresh = pollStreamOnce(state, { root, sinceMs: opts.sinceMs || (nowMs - 24 * 60 * 60 * 1000), agent: opts.agent, deps: allDeps, nowMs: allDeps.now() });
       if (fresh.length) console.log(renderRecords(fresh, opts));
     } finally {

package/commands/task.js

@@ -7922,6 +7922,8 @@ function publicWords(value) {
     ]).has(word));
 }
 
+const { memberTypeOf } = require('../lib/member-type');
+
 function parseMemberFrontmatter(text) {
   const source = String(text || '');
   if (!source.startsWith('---')) return {};
@@ -7952,6 +7954,7 @@ function readTeamMembers(root = process.cwd()) {
         slug,
         role: cleanPublicText(frontmatter.role || slug.replace(/[-_]/g, ' '), 120),
         description: cleanPublicText(frontmatter.description || '', 240),
+        type: memberTypeOf(frontmatter).type,
         path: memberPath,
       };
     })
@@ -8018,6 +8021,8 @@ function chooseTaskOwner({ purpose, tag, requestedOwner, root = process.cwd() }
   const words = publicWords(`${purpose || ''} ${tag || ''}`);
   let best = null;
   for (const member of members) {
+    // A person can be named as an owner, but routing never hands them work as if they were an AI.
+    if (member.type !== 'ai') continue;
     const score = scoreTeamMember(member, words, tag);
     if (!best || score > best.score) best = { member, score };
   }
@@ -13465,6 +13470,8 @@ async function run(args) {
 
 module.exports = {
   run,
+  chooseTaskOwner,
+  readTeamMembers,
   createTaskApiServer,
   taskDayGroups,
   taskDayTextGroups,

package/commands/team.js

@@ -7,6 +7,7 @@ const { canonicalEngineName } = require('../lib/engine-registry');
 const taskDb = require('../lib/task-db');
 const { buildTeamPresence, DEFAULT_FRESHNESS_WINDOW_MS, renderTeamPresence } = require('../lib/team-presence');
 const { LINEUP_UNREADABLE, memberLineup, readLineupSafe, renderLineup } = require('../lib/team-lineup');
+const { isMemberParked, isParkedFrontmatter, setMemberParked } = require('../lib/member-park');
 const { readEngineRegistry } = require('./engine');
 const { listMissions, listWorktreeRollupMissions } = require('./mission');
 const { collectSnapshot, collectStreamEvents, repoRoot } = require('./stream');
@@ -34,12 +35,14 @@ function collectTeamPresence(deps = {}) {
   const root = deps.root || repoRoot(deps.cwd || process.cwd());
   const nowMs = typeof deps.now === 'function' ? deps.now() : Date.now();
   const freshnessWindowMs = deps.freshnessWindowMs || DEFAULT_FRESHNESS_WINDOW_MS;
-  const stream = deps.stream || collectSnapshot({ root, deps: deps.streamDeps });
+  const skipLanding = Boolean(deps.skipLanding);
+  const stream = deps.stream || collectSnapshot({ root, deps: deps.streamDeps, skipLanding });
   const streamEvents = deps.streamEvents || collectStreamEvents({
     root,
     sinceMs: nowMs - freshnessWindowMs,
     nowMs,
     deps: deps.streamDeps,
+    skipLanding,
   });
   return buildTeamPresence({
     nowMs,
@@ -174,7 +177,9 @@ function escapeHtml(text) {
 
 function collectTeamRoster(deps = {}) {
   const root = deps.root || repoRoot(deps.cwd || process.cwd());
-  const presence = deps.presence || collectTeamPresence(deps);
+  // The roster only reads who is awake, never the landing wait, so it skips
+  // the landing board entirely.
+  const presence = deps.presence || collectTeamPresence({ ...deps, skipLanding: true });
   const awake = new Set(presence.members.map((member) => String(member.name || '').trim().toLowerCase()));
   const engineRoster = deps.engineRoster || readEngineRegistry(root, { persist: false }).engines;
   const engineByOwner = new Map();
@@ -206,6 +211,7 @@ function collectTeamRoster(deps = {}) {
         now: rawNow,
         focus,
         active,
+        parked: isParkedFrontmatter(member?.frontmatter),
       };
     })
     .filter((entry) => entry.name)
@@ -228,10 +234,30 @@ function wrapCommaNames(names, width = 80) {
   return lines.join('\n');
 }
 
-function renderTeamRoster(rosterRows, deps = {}) {
-  if (!rosterRows.length) {
+// Parked members leave the lists and come back as one line, unless --all
+// asks for them in place.
+function parkedSummaryLine(parkedRows, width = 80) {
+  if (!parkedRows.length) return '';
+  const names = parkedRows.map((entry) => entry.name);
+  names[0] = `parked (${parkedRows.length}): ${names[0]}`;
+  names[names.length - 1] = `${names[names.length - 1]} · atris team --all to show them`;
+  return wrapCommaNames(names, width);
+}
+
+function withParkedLabels(rosterRows, all) {
+  const parkedRows = rosterRows.filter((entry) => entry.parked);
+  if (!all) return { rows: rosterRows.filter((entry) => !entry.parked), parkedRows };
+  return {
+    rows: rosterRows.map((entry) => (entry.parked ? { ...entry, name: `${entry.name} (parked)` } : entry)),
+    parkedRows: [],
+  };
+}
+
+function renderTeamRoster(allRows, deps = {}) {
+  if (!allRows.length) {
     return 'no team members yet. create one with: atris member create <name> --role="..."';
   }
+  const { rows: rosterRows, parkedRows } = withParkedLabels(allRows, Boolean(deps.all));
   const activeRows = rosterRows.filter((entry) => entry.active);
   const restRows = rosterRows.filter((entry) => !entry.active);
   const termWidth = deps.termWidth || process.stdout.columns || 80;
@@ -260,6 +286,11 @@ function renderTeamRoster(rosterRows, deps = {}) {
   } else {
     lines.push('(none)');
   }
+  const parkedLine = parkedSummaryLine(parkedRows, termWidth);
+  if (parkedLine) {
+    lines.push('');
+    lines.push(parkedLine);
+  }
   return lines.join('\n');
 }
 
@@ -273,7 +304,8 @@ function renderTeamWithLineup(rosterRows, lineup, deps = {}) {
   return block ? `${block}\n\n${today}` : today;
 }
 
-function renderTeamRosterHtml(rosterRows, meta = {}) {
+function renderTeamRosterHtml(allRows, meta = {}) {
+  const rosterRows = withParkedLabels(allRows, Boolean(meta.all)).rows;
   const activeRows = rosterRows.filter((entry) => entry.active);
   const restRows = rosterRows.filter((entry) => !entry.active);
   const generatedAt = meta.generatedAt || new Date().toISOString();
@@ -418,6 +450,7 @@ function writeTeamBoardHtml(rosterRows, deps = {}) {
   const outPath = path.join(workspace, 'atris', 'team', 'team-board.html');
   fs.mkdirSync(path.dirname(outPath), { recursive: true });
   const html = renderTeamRosterHtml(rosterRows, {
+    all: Boolean(deps.all),
     workspace,
     generatedAt: deps.generatedAt || new Date().toISOString(),
   });
@@ -465,6 +498,8 @@ function collectTeamPrune(deps = {}) {
   for (const member of collectMembers(root, deps)) {
     const name = String(member?.name || '').trim().toLowerCase();
     if (!name) continue;
+    // A parked member is already set aside on purpose; flagging it again is noise.
+    if (isMemberParked(root, name)) continue;
     const signalMs = newestSignalMs(member);
     if (activeOwners.has(name) || (signalMs && nowMs - signalMs < days * DAY_MS)) {
       activeCount += 1;
@@ -497,14 +532,47 @@ function renderTeamPrune(report, days = DEFAULT_PRUNE_DAYS) {
 function helpText() {
   return [
     'atris team - who does each job, with its tool and model, then active members and the rest',
+    'atris team --all - also list parked members in place',
     'atris team presence - show who is awake and what they are doing',
     'atris team prune - flag members with no recent activity; deletes nothing',
+    'atris team park <name> [--note "<reason>"] - hide a member from the team views; it still runs by name',
+    'atris team unpark <name> - bring a parked member back',
     '',
-    'usage: atris team [roster|presence] [--json] [--html]',
+    'usage: atris team [roster|presence] [--all] [--json] [--html]',
     'usage: atris team prune [--days N] [--json]',
+    'usage: atris team park <name> [--note "<reason>"] | atris team unpark <name>',
   ].join('\n');
 }
 
+const PARK_USAGE = 'usage: atris team park <name> [--note "<reason>"] | atris team unpark <name>';
+
+function teamParkCommand(parked, rest, deps = {}) {
+  const write = deps.write || process.stdout.write.bind(process.stdout);
+  const error = deps.error || process.stderr.write.bind(process.stderr);
+  let name = '';
+  let note = '';
+  let bad = false;
+  for (let i = 0; i < rest.length; i += 1) {
+    const arg = rest[i];
+    if (parked && arg === '--note') { i += 1; note = rest[i] || ''; if (!note) bad = true; continue; }
+    if (parked && arg.startsWith('--note=')) { note = arg.slice('--note='.length); continue; }
+    if (arg.startsWith('-') || name) { bad = true; continue; }
+    name = arg;
+  }
+  if (bad || !name) {
+    error(`${PARK_USAGE}\n`);
+    return 2;
+  }
+  const root = deps.root || repoRoot(deps.cwd || process.cwd());
+  const result = setMemberParked(root, name, { parked, note, now: deps.now ? new Date(deps.now()) : new Date() });
+  if (!result.ok) {
+    error(`${result.error}\n`);
+    return 1;
+  }
+  write(`${result.message}\n`);
+  return 0;
+}
+
 function teamCommand(args = [], deps = {}) {
   if (args.includes('--help') || args.includes('-h') || args[0] === 'help') {
     (deps.write || process.stdout.write.bind(process.stdout))(`${helpText()}\n`);
@@ -531,18 +599,22 @@ function teamCommand(args = [], deps = {}) {
     (deps.write || process.stdout.write.bind(process.stdout))(`${output}\n`);
     return 0;
   }
+  if (args[0] === 'park' || args[0] === 'unpark') {
+    return teamParkCommand(args[0] === 'park', args.slice(1), deps);
+  }
   const rosterArgs = args.filter((arg) => arg !== 'roster');
-  const rosterFlags = new Set(['--json', '--html']);
+  const rosterFlags = new Set(['--json', '--html', '--all']);
   if (args[0] !== 'presence' && rosterArgs.every((arg) => rosterFlags.has(arg))) {
     const html = rosterArgs.includes('--html');
     const json = rosterArgs.includes('--json');
+    const all = rosterArgs.includes('--all');
     if (html && json) {
       (deps.error || process.stderr.write.bind(process.stderr))('usage: atris team [--json] [--html] (not both)\n');
       return 2;
     }
     const roster = deps.roster || collectTeamRoster(deps);
     if (html) {
-      const outPath = writeTeamBoardHtml(roster, deps);
+      const outPath = writeTeamBoardHtml(roster, { ...deps, all });
       (deps.write || process.stdout.write.bind(process.stdout))(`${outPath}\n`);
       return 0;
     }
@@ -554,12 +626,12 @@ function teamCommand(args = [], deps = {}) {
       : readLineupSafe(deps.root || repoRoot(deps.cwd || process.cwd()), deps.lineupNow || new Date());
     const output = json
       ? JSON.stringify(roster.map((entry) => ({ ...entry, lineup: memberLineup(lineup, entry.name) })), null, 2)
-      : renderTeamWithLineup(roster, lineup, deps);
+      : renderTeamWithLineup(roster, lineup, { ...deps, all });
     (deps.write || process.stdout.write.bind(process.stdout))(`${output}\n`);
     return 0;
   }
   if (args[0] !== 'presence' || args.some((arg, index) => index > 0 && arg !== '--json')) {
-    (deps.error || process.stderr.write.bind(process.stderr))('usage: atris team [roster|presence|prune] [--json] [--html]\n');
+    (deps.error || process.stderr.write.bind(process.stderr))('usage: atris team [roster|presence|prune|park|unpark] [--all] [--json] [--html]\n');
     return 2;
   }
   const presence = deps.presence || collectTeamPresence(deps);

package/commands/transactions.js

@@ -0,0 +1,115 @@
+'use strict';
+
+// atris transactions: every order, fee, trade, and wallet send, newest first.
+// Read only. Backend: GET /api/transactions.
+
+const { apiRequestJson } = require('../utils/api');
+const { loadCredentials } = require('../utils/auth');
+const { NOT_LOGGED_IN, tokenFrom, oneLine, printResult } = require('../lib/developer-api');
+const { parseFlags, formatCents, errorFrom } = require('../lib/commerce');
+
+const TX_KINDS = ['ticket', 'shop', 'flight', 'test_purchase', 'fee', 'trade', 'wallet_send'];
+
+function showTransactionsHelp(log = console.log) {
+  log(`usage: atris transactions [--since YYYY-MM-DD] [--kind k[,k]] [--limit n] [--include-quotes] [--json]
+
+list what you bought, paid in fees, traded, or sent, newest first. read only.
+
+  --since   only rows on or after this date, like 2026-09-01
+  --kind    ${TX_KINDS.join(', ')}
+  --limit   1 to 200 (default 50)
+  --include-quotes  also list quotes nobody approved`);
+}
+
+function clip(text, width) {
+  const s = String(text == null ? '' : text).replace(/\s+/g, ' ').trim();
+  return s.length > width ? `${s.slice(0, width - 1)}…` : s;
+}
+
+function whenText(value) {
+  const s = String(value || '');
+  const m = s.match(/^(\d{4}-\d{2}-\d{2})[T ](\d{2}:\d{2})/);
+  return m ? `${m[1]} ${m[2]}` : clip(s, 16);
+}
+
+function renderTransactions(data = {}) {
+  const rows = Array.isArray(data.transactions) ? data.transactions : [];
+  const lines = [];
+  if (!rows.length) lines.push('No transactions yet.');
+  else {
+    const table = rows.map((r) => [
+      whenText(r.when),
+      clip(r.kind, 12),
+      clip(r.what, 40),
+      formatCents(r.amount_cents, r.currency),
+      clip(r.state, 16),
+    ]);
+    const head = ['WHEN', 'KIND', 'WHAT', 'AMOUNT', 'STATE'];
+    const widths = head.map((h, i) => Math.max(h.length, ...table.map((row) => row[i].length)));
+    const fmt = (row) => row.map((cell, i) => (i === 3 ? cell.padStart(widths[i]) : cell.padEnd(widths[i])))
+      .join('  ').trimEnd();
+    lines.push(fmt(head));
+    for (const row of table) lines.push(fmt(row));
+  }
+  const down = Object.entries(data.sources || {}).filter(([, v]) => v !== 'ok').map(([k]) => k);
+  if (down.length) lines.push('', `Partial list: could not load ${down.join(', ')}.`);
+  return lines.join('\n');
+}
+
+function buildQuery(flags) {
+  const params = new URLSearchParams();
+  if (flags.since != null) {
+    const since = String(flags.since).trim();
+    if (!/^\d{4}-\d{2}-\d{2}/.test(since)) return { ok: false, error: '--since must be a date like 2026-09-01' };
+    params.set('since', since);
+  }
+  const rawKind = flags.kind != null ? flags.kind : flags.kinds;
+  if (rawKind != null) {
+    const kinds = String(rawKind).split(',').map((k) => k.trim().toLowerCase()).filter(Boolean);
+    const bad = kinds.filter((k) => !TX_KINDS.includes(k));
+    if (bad.length || !kinds.length) return { ok: false, error: `--kind must be one of ${TX_KINDS.join(', ')}` };
+    params.set('kinds', kinds.join(','));
+  }
+  if (flags.limit != null) {
+    const limit = Number(flags.limit);
+    if (!Number.isInteger(limit) || limit < 1 || limit > 200) return { ok: false, error: '--limit must be a number from 1 to 200' };
+    params.set('limit', String(limit));
+  }
+  if (flags.include_quotes === true) params.set('include_quotes', 'true');
+  const qs = params.toString();
+  return { ok: true, path: qs ? `/transactions?${qs}` : '/transactions' };
+}
+
+async function transactionsCommand(args = [], deps = {}) {
+  const io = { log: deps.log || console.log, err: deps.err || console.error };
+  const { flags, pos } = parseFlags(args);
+  if (flags.help || pos[0] === 'help') {
+    showTransactionsHelp(io.log);
+    return 0;
+  }
+  const json = flags.json === true;
+  const fail = (error, status) => {
+    printResult({ json, ok: false, error, payload: { ok: false, error, ...(status ? { status } : {}) } }, io);
+    return 1;
+  };
+
+  const query = buildQuery(flags);
+  if (!query.ok) return fail(query.error);
+
+  const load = deps.loadCredentials || loadCredentials;
+  const request = deps.apiRequestJson || apiRequestJson;
+  const token = tokenFrom(load());
+  if (!token) return fail(NOT_LOGGED_IN);
+
+  try {
+    const result = await request(query.path, { method: 'GET', token });
+    if (!result || !result.ok) return fail(errorFrom(result), result && result.status);
+    const data = result.data || {};
+    printResult({ json, ok: true, text: renderTransactions(data), payload: { ok: true, ...data } }, io);
+    return 0;
+  } catch (error) {
+    return fail(oneLine(error && error.message));
+  }
+}
+
+module.exports = { transactionsCommand };