atris 3.60.0 → 3.62.0

package/commands/member.js

@@ -11,7 +11,7 @@ const { defaultObjectiveRunner } = require('../lib/default-runner');
 const { readJson, writeJson } = require('../lib/json-file');
 const { sleepSync } = require('../lib/sleep-sync');
 const { hasFlag, readFlag, readNumberFlag } = require('../lib/arg-parser');
-const { ensureMemberBundle, memberBundlePresent } = require('../lib/member-scaffold');
+const { ensureMemberBundle, memberBundlePresent, updateMemberSkills } = require('../lib/member-scaffold');
 const { memberProcessPrompt, MEMBER_PROCESS_PATH } = require('../lib/member-context');
 
 function findWorkspaceBusinessId(startDir = process.cwd()) {
@@ -1078,6 +1078,13 @@ function memberRun(name, ...args) {
 
   const asJson = hasFlag(args, '--json');
   const paths = requireMemberDir(name);
+  // Parking only hides a member from the team views; a run by name still goes.
+  const { isParkedText } = require('../lib/member-park');
+  try {
+    if (isParkedText(fs.readFileSync(paths.memberFile, 'utf8'))) {
+      console.error(`${name} is parked; running anyway`);
+    }
+  } catch { /* an unreadable card is requireMemberDir's problem, not this notice's */ }
   const requestedVerifier = readFlag(args, '--verify', '') || memberRunConfiguredVerifier(paths);
   const missionText = memberRunMissionText(args);
   const hasMissionOverride = Boolean(readFlag(args, '--mission', '') || readFlag(args, '--mission-id', ''));
@@ -4095,6 +4102,8 @@ function memberList(...flags) {
   const asJson = flags.includes('--json') || process.argv.includes('--json');
   const teamDir = path.join(process.cwd(), 'atris', 'team');
   const members = findAllMembers(teamDir);
+  const { isMemberParked } = require('../lib/member-park');
+  const parked = new Set(members.filter((m) => isMemberParked(process.cwd(), m.name)).map((m) => m.name));
 
   if (asJson) {
     console.log(JSON.stringify({
@@ -4102,6 +4111,7 @@ function memberList(...flags) {
       count: members.length,
       members: members.map((m) => ({
         name: m.name,
+        ...(parked.has(m.name) ? { parked: true } : {}),
         role: m.role,
         format: m.format,
         skills: m.format === 'directory' ? m.skillCount : null,
@@ -4149,12 +4159,14 @@ function memberList(...flags) {
       clipCell(m.format === 'directory' ? 'dir' : 'flat', fmtW) +
       clipCell(skills, skillW) +
       clipCell(context, ctxW) +
-      (m.version || '-')
+      (m.version || '-') +
+      (parked.has(m.name) ? '  parked' : '')
     );
   }
 
   console.log('');
-  console.log(`${members.length} ${members.length === 1 ? 'member' : 'members'} found.`);
+  const parkedNote = parked.size ? ` (${parked.size} parked; unpark with atris team unpark <name>)` : '';
+  console.log(`${members.length} ${members.length === 1 ? 'member' : 'members'} found.${parkedNote}`);
 }
 
 // --- CREATE subcommand ---
@@ -4296,10 +4308,10 @@ tools: []
 }
 
 function printMemberInstallUsage(stream = console.log) {
-  stream('Usage: atris member install <slug>');
+  stream('Usage: atris member install <slug> [--update]');
 }
 
-function memberInstall(slug) {
+function memberInstall(slug, update = false) {
   if (slug === '--help' || slug === '-h') {
     printMemberInstallUsage();
     return;
@@ -4314,9 +4326,22 @@ function memberInstall(slug) {
   }
 
   const memberDir = path.join(process.cwd(), 'atris', 'team', slug);
+  const templateDir = path.join(__dirname, '..', 'templates', 'members', slug);
+  if (update) {
+    if (!fs.existsSync(templateDir)) {
+      console.error(`No member template for ${slug}.`);
+      process.exit(1);
+    }
+    const updated = updateMemberSkills(templateDir, memberDir);
+    if (updated.length === 0) {
+      console.log(`MEMBER ${slug} already up to date`);
+    } else {
+      for (const rel of updated) console.log(`atris/team/${slug}/${rel.split(path.sep).join('/')}`);
+    }
+    return;
+  }
   const already = memberBundlePresent(memberDir);
   fs.mkdirSync(path.join(memberDir, 'logs'), { recursive: true });
-  const templateDir = path.join(__dirname, '..', 'templates', 'members', slug);
   const copied = [];
   if (fs.existsSync(templateDir)) {
     const copyMissing = (source, relative = '') => {
@@ -9332,7 +9357,7 @@ async function memberCommand(subcommand, ...args) {
     case 'new':
       return memberCreate(args[0], ...args.slice(1));
     case 'install':
-      return memberInstall(args[0]);
+      return memberInstall(args[0], args.includes('--update'));
     case 'activate':
       return memberActivate(args[0]);
     case 'upgrade':
@@ -9394,7 +9419,7 @@ async function memberCommand(subcommand, ...args) {
       console.log('');
       console.log('Subcommands:');
       console.log('  create <name>       Scaffold a new team member (MEMBER.md + dirs) [--push]');
-      console.log('  install <slug>      Install the full MEMBER bundle if missing; never overwrite');
+      console.log('  install <slug> [--update]  Install missing files, or refresh template skills');
       console.log('  chat <name> "..."   Send a message to this member\'s desk in Atris Desktop');
       console.log('  list [--json]       Show all team members');
       console.log('  activate <name>     Symlink member skills, show context and permissions');

package/commands/mission.js

@@ -32,8 +32,11 @@ const {
 const {
   resolveEngineForRoleWithPreference,
   engineFailureHealthStatus,
+  engineStallReason,
+  recordEngineRunHealth,
   setEngineHealth,
 } = require('../lib/engine-registry');
+const { appendRosterRun, parseRunUsage } = require('../lib/roster-runs');
 const {
   FUNCTIONAL_MEMBER_TOPICS,
   listWorkspaceMemberSlugs,
@@ -391,9 +394,29 @@ function rosterTickPins(engine) {
   return {
     ...(engine && engine.roster_effort ? { roster_effort: engine.roster_effort } : {}),
     ...(engine && engine.roster_max_seconds ? { roster_max_seconds: engine.roster_max_seconds } : {}),
+    ...(engine && engine.roster_prep ? { roster_prep: engine.roster_prep } : {}),
   };
 }
 
+// A tick whose roster worker asks for prep ("prep: search") runs the same
+// prep pass fleet runs before the worker starts, and the worker's prompt
+// gets the brief. No prep line means the prompt goes out as it was.
+async function missionTickPrep(root, { mission, runtimeMission, job, prompt, ask } = {}) {
+  const prepJob = String(runtimeMission && runtimeMission.roster_prep || '').trim();
+  if (!prepJob) return { prompt, prep: null };
+  const { runPrepPass, withPrepBrief } = require('../lib/roster-prep');
+  const prep = await runPrepPass({
+    prepJob,
+    forJob: job || 'build',
+    task: { display_id: (mission && mission.id) || '', title: (mission && (mission.objective || mission.slug)) || '' },
+    prompt,
+    root,
+    record: { member: (mission && mission.owner) || '' },
+    ...(ask ? { ask } : {}),
+  });
+  return { prompt: withPrepBrief(prompt, prep), prep };
+}
+
 // A tick's time limit: the time left on the mission, capped by the roster
 // line's "max 20 min" when it sets one, else by the default tick cap.
 function missionTickTimeoutMs(mission, remainingMs) {
@@ -427,6 +450,7 @@ function resolveMissionTickRunner(mission, root = process.cwd(), options = {}) {
         requested_engine: null,
         engine_fallback_reason: null,
         member_engine_reason: member.reason,
+        roster_job: member.job || 'build',
       };
     }
   }
@@ -445,10 +469,59 @@ function resolveMissionTickRunner(mission, root = process.cwd(), options = {}) {
   };
 }
 
+// A stalled tick benches its engine for the cooldown, so the next tick's
+// roster pick is the backup; no retry inside the tick is needed.
 function recordMissionEngineTickOutcome(engineId, result, root = process.cwd()) {
   if (!engineId) return null;
-  const status = result && result.status === 'ran' ? 'ready' : engineFailureHealthStatus(result);
-  return status ? setEngineHealth(engineId, status, root) : null;
+  if (result && result.status === 'ran') return setEngineHealth(engineId, 'ready', root);
+  if (!engineFailureHealthStatus(result)) return null;
+  return recordEngineRunHealth(engineId, result, root);
+}
+
+// One run-record line per engine tick: how long the worker ran, and how it
+// ended. A tick that ran and passed (or had no verifier) landed; a failing
+// verifier or a real error failed; a time cap or dropped connection stalled;
+// a closed credit window is credit out. Never throws into the tick.
+function missionTickRunOutcome(result, verifierResult, maxSeconds) {
+  if (result && result.status === 'ran') {
+    return verifierResult && verifierResult.passed === false
+      ? { outcome: 'failed', detail: 'the verifier failed' }
+      : { outcome: 'landed' };
+  }
+  if (engineFailureHealthStatus(result) === 'credit_out') return { outcome: 'credit out', detail: 'the engine hit its usage limit' };
+  const stall = engineStallReason({ ...result, ...(maxSeconds ? { max_seconds: maxSeconds } : {}) });
+  if (stall) return { outcome: 'stalled', detail: stall.text };
+  if (/wall-exceeded/.test(String(result && result.reason || ''))) return { outcome: 'failed', detail: 'the mission ran out of time' };
+  const summary = String(result && result.claude && result.claude.summary || '').split('\n')[0].trim();
+  return { outcome: 'failed', detail: summary && summary !== 'error' ? summary : String(result && result.reason || 'the tick failed').replace(/-/g, ' ') };
+}
+
+function recordMissionTickRosterRun(root, { mission, runtimeMission, engineId, job, result, verifierResult, startedAt, endedMs, usage, prep = null } = {}) {
+  if (!engineId) return null;
+  try {
+    const { engineRunsView } = require('../lib/roster-models');
+    const { prepRecordFields } = require('../lib/roster-prep');
+    const run = runtimeMission || mission || {};
+    const startedMs = Date.parse(startedAt);
+    const maxSeconds = Number(run.roster_max_seconds) || 0;
+    return appendRosterRun(root, {
+      at: startedAt,
+      job: job || 'build',
+      member: (mission && mission.owner) || '',
+      engine: engineId,
+      model: run.model || engineRunsView(engineId).model || '',
+      effort: run.roster_effort || '',
+      max_seconds: maxSeconds,
+      seconds: Number.isFinite(startedMs) ? Math.max(0, (endedMs - startedMs) / 1000) : undefined,
+      task: (mission && mission.id) || '',
+      source: 'mission',
+      ...prepRecordFields(prep),
+      ...(usage || {}),
+      ...missionTickRunOutcome(result, verifierResult, maxSeconds),
+    });
+  } catch {
+    return null;
+  }
 }
 
 function runnerModelPatch(runner, model) {
@@ -8904,6 +8977,7 @@ function spawnGenericRunnerTick(mission, opts) {
         stop_reason: null,
         stderr: errStr,
         parse_errors: 0,
+        run_usage: parseRunUsage({ stdout, stderr }),
       });
     });
 
@@ -9008,6 +9082,7 @@ function spawnClaudeTick(mission, opts) {
     let numTurns = null;
     let rateLimitInfo = null;
     let stopReason = null;
+    let usage = null;
     let parseErrors = 0;
     let stderr = '';
     let timedOut = false;
@@ -9047,6 +9122,7 @@ function spawnClaudeTick(mission, opts) {
             if (typeof ev.duration_api_ms === 'number') durationApiMs = ev.duration_api_ms;
             if (typeof ev.num_turns === 'number') numTurns = ev.num_turns;
             if (ev.stop_reason) stopReason = ev.stop_reason;
+            if (ev.usage && typeof ev.usage === 'object') usage = ev.usage;
           }
         } catch {
           parseErrors++;
@@ -9083,6 +9159,7 @@ function spawnClaudeTick(mission, opts) {
         rate_limit_info: rateLimitInfo,
         stderr: errStr,
         parse_errors: parseErrors,
+        run_usage: parseRunUsage({ usage, cost_usd: costEstimate }),
       });
     });
 
@@ -9571,6 +9648,9 @@ async function executeMissionRunTicksPhase(context) {
       const tickStart = stampIso();
       const tickWorktreeBefore = gitWorktreeSnapshot(cwd);
       let result = { status: 'skipped', reason: 'unknown', tick_index: tickIdx, ran: false, started_at: tickStart };
+      // Set when a roster engine really ran this tick: when it stopped and the
+      // usage it printed. The run record is written after the verifier.
+      let tickWorkerRun = null;
       let cachedStep = findCachedMissionStepReceipt(cwd, { missionId: mission.id, tickIndex: tickIdx });
       let cachedVerifierResult = cachedStep ? cachedStep.verifier_result : null;
       const tickSelection = resolveMissionTickRunner(runtimeMission, cwd);
@@ -9707,6 +9787,7 @@ async function executeMissionRunTicksPhase(context) {
             backend_unavailable: isTransientAtris2BackendError(turn.error) || undefined,
             receipt_text: String(turn.text || '').slice(0, 4000),
           };
+          tickWorkerRun = { endedMs: Date.now(), usage: {} };
           if (controller.signal.aborted) { pauseReason = 'aborted-during-atris2'; break; }
           if (turn.error === 'not-logged-in') { pauseReason = 'auth-required'; break; }
           if (wallExpired) {
@@ -9724,6 +9805,17 @@ async function executeMissionRunTicksPhase(context) {
         const pingDrain = consumeMissionPings(mission, cwd);
         mission = pingDrain.mission;
         runtimeMission = runtimeView(mission);
+        let tickPrep = null;
+        let workerPrompt = prompt;
+        if (tickEngineId) {
+          ({ prompt: workerPrompt, prep: tickPrep } = await missionTickPrep(cwd, {
+            mission,
+            runtimeMission: tickRuntimeMission,
+            job: tickSelection.roster_job || 'build',
+            prompt,
+          }));
+        }
+        const workerStartedAt = tickPrep ? stampIso() : tickStart;
         const restoreTickRunnerProfile = tickEngineId ? applyMissionRunnerProfile(tickEngineId) : () => {};
         let claudeResult;
         let sessionBusyRetried = false;
@@ -9734,7 +9826,7 @@ async function executeMissionRunTicksPhase(context) {
             tickRuntimeMission,
             (maxWallSeconds - ((Date.now() - startedAt) / 1000)) * 1000,
           ),
-          prompt,
+          prompt: workerPrompt,
           model: resolveMissionTickRunnerModel(tickRuntimeMission),
         });
         try {
@@ -9754,6 +9846,7 @@ async function executeMissionRunTicksPhase(context) {
         } finally {
           restoreTickRunnerProfile();
         }
+        tickWorkerRun = { endedMs: Date.now(), usage: (claudeResult && claudeResult.run_usage) || {}, prep: tickPrep, startedAt: workerStartedAt };
         result.claude = {
           ok: claudeResult.ok,
           reason: claudeResult.reason,
@@ -9860,6 +9953,20 @@ async function executeMissionRunTicksPhase(context) {
       }
       pauseReason = context.pauseReason;
       context.currentTick = null;
+      if (tickEngineId && !cachedStep && tickWorkerRun) {
+        recordMissionTickRosterRun(cwd, {
+          mission,
+          runtimeMission: tickRuntimeMission,
+          engineId: tickEngineId,
+          job: tickSelection.roster_job || 'build',
+          result,
+          verifierResult,
+          startedAt: tickWorkerRun.startedAt || tickStart,
+          endedMs: tickWorkerRun.endedMs,
+          usage: tickWorkerRun.usage,
+          prep: tickWorkerRun.prep || null,
+        });
+      }
       let receiptPath = cachedStep ? cachedStep.receipt_path : null;
 
       // Review-lane drain: always-on loops sweep the agent-safe review actions
@@ -11792,6 +11899,8 @@ module.exports = {
   missionTickTimeoutMs,
   engineFailureHealthStatus,
   recordMissionEngineTickOutcome,
+  recordMissionTickRosterRun,
+  missionTickPrep,
   tickMadeProgress,
   consecutiveNoProgressTicks,
   consecutiveIdenticalSummaryTicks,

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 {