tmux-team 4.0.0 → 4.2.0

package/src/commands/team.ts

@@ -0,0 +1,361 @@
+// ─────────────────────────────────────────────────────────────
+// team command - inspect pane team/workspace scope and manage explicit shared teams
+// ─────────────────────────────────────────────────────────────
+
+import type { Context, RegistryScope, TeamPaneInfo, TeamPaneRegistration } from '../types.js';
+import { ExitCodes } from '../exits.js';
+import { registrationFromEntry } from '../registry.js';
+
+export function cmdTeam(ctx: Context, args: string[]): void {
+  const subcommand = args[0];
+
+  switch (subcommand) {
+    case undefined:
+      listTeamNames(ctx, []);
+      break;
+    case 'ls':
+    case 'list':
+      listTeamMembers(ctx, args.slice(1));
+      break;
+    case 'add':
+      addTeamMember(ctx, args.slice(1));
+      break;
+    case 'rm':
+    case 'remove':
+      removeTeam(ctx, args.slice(1));
+      break;
+    case 'panes':
+    case 'inventory':
+      listPaneInventory(ctx, args.slice(1));
+      break;
+    default:
+      ctx.ui.error(`Unknown team subcommand: ${subcommand}`);
+      ctx.ui.error(
+        'Usage: tmux-team team [ls <team>|add <team> <name> [pane]|rm <team> --force|panes]'
+      );
+      ctx.exit(ExitCodes.ERROR);
+  }
+}
+
+function listTeamNames(ctx: Context, args: string[]): void {
+  const teams = ctx.tmux.listTeams();
+  const summaryOnly = args.includes('--summary');
+
+  if (ctx.flags.json) {
+    ctx.ui.json({ teams });
+    return;
+  }
+
+  const rows = Object.entries(teams).sort(([a], [b]) => a.localeCompare(b));
+  if (rows.length === 0) {
+    ctx.ui.info('No shared teams found.');
+    return;
+  }
+
+  if (summaryOnly) {
+    ctx.ui.table(
+      ['TEAM', 'AGENTS'],
+      rows.map(([teamName, agents]) => [teamName, agents.join(', ') || '-'])
+    );
+    return;
+  }
+
+  ctx.ui.table(
+    ['TEAM', 'MEMBERS'],
+    rows.map(([teamName, agents]) => [teamName, String(agents.length)])
+  );
+}
+
+export function listTeamMembers(ctx: Context, args: string[]): void {
+  const teamName = args.find((arg) => !arg.startsWith('-'));
+  if (!teamName) {
+    listTeamNames(ctx, args);
+    return;
+  }
+
+  const rows = teamMemberRows(ctx.tmux.listTeamPanes(), teamName);
+  if (ctx.flags.json) {
+    ctx.ui.json({ team: teamName, members: rows.map(rowToMemberJson) });
+    return;
+  }
+
+  if (rows.length === 0) {
+    ctx.ui.info(
+      `No agents in team "${teamName}". Use 'tmt team add ${teamName} <name>' to add one.`
+    );
+    return;
+  }
+
+  ctx.ui.table(['NAME', 'PANE', 'TARGET', 'CWD', 'CMD', 'REMARK'], rows);
+}
+
+function addTeamMember(ctx: Context, args: string[]): void {
+  const [teamName, name, maybePane, ...remarkParts] = args.filter((arg) => !arg.startsWith('-'));
+  if (!teamName || !name) {
+    ctx.ui.error('Usage: tmux-team team add <team> <name> [pane] [remark]');
+    ctx.exit(ExitCodes.ERROR);
+  }
+
+  const scope: RegistryScope = { type: 'team', teamName };
+  const registry = ctx.tmux.getAgentRegistry(scope);
+  if (registry.paneRegistry[name]) {
+    ctx.ui.error(
+      `Agent '${name}' already exists in team '${teamName}'. Use 'tmux-team update --team ${teamName}' to modify.`
+    );
+    ctx.exit(ExitCodes.ERROR);
+  }
+
+  const targetPane = maybePane ?? ctx.tmux.getCurrentPaneId();
+  if (!targetPane) {
+    ctx.ui.error(
+      'Not running inside tmux. Provide a pane target: tmt team add <team> <name> <pane>'
+    );
+    ctx.exit(ExitCodes.ERROR);
+  }
+
+  const resolvedPane = ctx.tmux.resolvePaneTarget(targetPane);
+  if (!resolvedPane) {
+    ctx.ui.error(`Pane '${targetPane}' not found. Is tmux running?`);
+    ctx.exit(ExitCodes.PANE_NOT_FOUND);
+  }
+
+  const remark = remarkParts.length > 0 ? remarkParts.join(' ') : undefined;
+  ctx.tmux.setAgentRegistration(
+    resolvedPane,
+    scope,
+    registrationFromEntry(name, {
+      pane: resolvedPane,
+      ...(remark !== undefined && { remark }),
+    })
+  );
+
+  if (ctx.flags.json) {
+    ctx.ui.json({ added: name, team: teamName, pane: resolvedPane, remark });
+    return;
+  }
+
+  ctx.ui.success(`Added agent '${name}' to team '${teamName}' at pane ${resolvedPane}`);
+}
+
+function listPaneInventory(ctx: Context, _args: string[]): void {
+  const teams = ctx.tmux.listTeams();
+  const panes = ctx.tmux.listTeamPanes();
+
+  if (ctx.flags.json) {
+    ctx.ui.json({ teams, panes });
+    return;
+  }
+
+  const groups = panesToGroups(panes);
+  if (groups.length === 0) {
+    ctx.ui.info('No tmux panes found.');
+    return;
+  }
+
+  for (const [index, group] of groups.entries()) {
+    if (index > 0) console.log('');
+    console.log(group.title);
+    ctx.ui.table(['PANE', 'TARGET', 'CWD', 'CMD'], group.rows);
+  }
+}
+
+export function listPaneStatus(ctx: Context, target: string): void {
+  const resolvedPane = resolvePaneLike(ctx, target);
+  if (!resolvedPane) {
+    ctx.ui.error(`Pane or team '${target}' not found.`);
+    ctx.exit(ExitCodes.PANE_NOT_FOUND);
+  }
+
+  const pane = ctx.tmux.listTeamPanes().find((item) => item.pane === resolvedPane);
+  if (!pane) {
+    ctx.ui.error(`Pane '${target}' not found.`);
+    ctx.exit(ExitCodes.PANE_NOT_FOUND);
+  }
+
+  if (ctx.flags.json) {
+    ctx.ui.json({ pane });
+    return;
+  }
+
+  console.log(`Pane: ${pane.pane}${pane.target ? ` (${pane.target})` : ''}`);
+  console.log(`CWD:  ${pane.cwd ?? '-'}`);
+  console.log(`CMD:  ${pane.command || '-'}`);
+
+  if (pane.registrations.length === 0) {
+    ctx.ui.info('No registrations on this pane.');
+    return;
+  }
+
+  ctx.ui.table(
+    ['SCOPE', 'NAME', 'REMARK'],
+    pane.registrations.map((registration) => [
+      registration.scopeType === 'team'
+        ? `team:${registration.scope}`
+        : `workspace:${registration.scope}`,
+      registration.agent,
+      registration.remark ?? '-',
+    ])
+  );
+}
+
+function resolvePaneLike(ctx: Context, target: string): string | null {
+  const candidates = [target];
+  const dotted = target.match(/^([^.]+)\.([^.]+)\.([^.]+)$/);
+  if (dotted) {
+    candidates.push(`${dotted[1]}:${dotted[2]}.${dotted[3]}`);
+  }
+
+  for (const candidate of candidates) {
+    const resolved = ctx.tmux.resolvePaneTarget(candidate);
+    if (resolved) return resolved;
+  }
+
+  return null;
+}
+
+function teamMemberRows(panes: TeamPaneInfo[], teamName: string): string[][] {
+  const rows: string[][] = [];
+  for (const pane of panes) {
+    for (const registration of pane.registrations) {
+      if (registration.scopeType !== 'team' || registration.scope !== teamName) continue;
+      rows.push([
+        registration.agent,
+        pane.pane,
+        pane.target ?? '-',
+        pane.cwd ?? '-',
+        pane.command || '-',
+        registration.remark ?? '-',
+      ]);
+    }
+  }
+  return rows.sort((a, b) => a[0].localeCompare(b[0]) || a[1].localeCompare(b[1]));
+}
+
+function rowToMemberJson(row: string[]): {
+  name: string;
+  pane: string;
+  target: string;
+  cwd: string;
+  command: string;
+  remark?: string;
+} {
+  return {
+    name: row[0],
+    pane: row[1],
+    target: row[2],
+    cwd: row[3],
+    command: row[4],
+    ...(row[5] !== '-' && { remark: row[5] }),
+  };
+}
+
+interface PaneGroup {
+  key: string;
+  title: string;
+  agents: Set<string>;
+  rows: string[][];
+}
+
+function panesToGroups(panes: TeamPaneInfo[]): PaneGroup[] {
+  const groups = new Map<string, PaneGroup>();
+
+  for (const pane of panes) {
+    if (pane.registrations.length === 0) {
+      addPaneToGroup(groups, '2:', 'Unregistered panes', pane);
+      continue;
+    }
+
+    for (const registration of pane.registrations) {
+      addPaneToGroup(
+        groups,
+        scopeSortKey(registration),
+        groupTitle(registration),
+        pane,
+        registration
+      );
+    }
+  }
+
+  return [...groups.values()]
+    .sort((a, b) => a.key.localeCompare(b.key))
+    .map((group) => ({
+      ...group,
+      title:
+        group.agents.size > 0
+          ? `${group.title} (${[...group.agents].sort().join(', ')})`
+          : group.title,
+      rows: group.rows.sort((a, b) => a[1].localeCompare(b[1])),
+    }));
+}
+
+function addPaneToGroup(
+  groups: Map<string, PaneGroup>,
+  key: string,
+  title: string,
+  pane: TeamPaneInfo,
+  registration?: TeamPaneRegistration
+): void {
+  const group = groups.get(key) ?? { key, title, agents: new Set<string>(), rows: [] };
+  if (registration) group.agents.add(formatAgent(registration));
+  group.rows.push([pane.pane, pane.target ?? '-', pane.cwd ?? '-', pane.command || '-']);
+  groups.set(key, group);
+}
+
+function scopeSortKey(registration: TeamPaneRegistration): string {
+  if (registration.scopeType === 'team') return `0:${registration.scope}`;
+  if (registration.scopeType === 'workspace') return `1:${registration.scope}`;
+  return '2:';
+}
+
+function groupTitle(registration: TeamPaneRegistration): string {
+  if (registration.scopeType === 'team') return `Team: ${registration.scope}`;
+  return `Workspace: ${registration.scope}`;
+}
+
+function formatAgent(registration: TeamPaneRegistration): string {
+  return registration.remark
+    ? `${registration.agent} (${registration.remark})`
+    : registration.agent;
+}
+
+function removeTeam(ctx: Context, args: string[]): void {
+  const teamName = args.find((arg) => !arg.startsWith('-'));
+  const dryRun = args.includes('--dry-run');
+  const force = ctx.flags.force || args.includes('--force') || args.includes('-f');
+
+  if (!teamName) {
+    ctx.ui.error('Usage: tmux-team team rm <team> --force');
+    ctx.exit(ExitCodes.ERROR);
+  }
+
+  const teams = ctx.tmux.listTeams();
+  const agents = teams[teamName] ?? [];
+  if (agents.length === 0) {
+    ctx.ui.error(`Team '${teamName}' not found.`);
+    ctx.exit(ExitCodes.PANE_NOT_FOUND);
+  }
+
+  if (ctx.flags.json && dryRun) {
+    ctx.ui.json({ team: teamName, dryRun: true, agents, removed: 0 });
+    return;
+  }
+
+  if (dryRun) {
+    ctx.ui.info(`Would remove team '${teamName}' from ${agents.length} agent(s).`);
+    ctx.ui.table(['TEAM', 'AGENTS'], [[teamName, agents.join(', ')]]);
+    return;
+  }
+
+  if (!force) {
+    ctx.ui.error(`Refusing to remove team '${teamName}' without --force.`);
+    ctx.exit(ExitCodes.ERROR);
+  }
+
+  const result = ctx.tmux.removeTeam(teamName);
+  if (ctx.flags.json) {
+    ctx.ui.json({ team: teamName, removed: result.removed, agents: result.agents });
+    return;
+  }
+
+  ctx.ui.success(`Removed team '${teamName}' from ${result.removed} pane(s).`);
+}

package/src/commands/update.ts

@@ -5,13 +5,14 @@
 import type { Context, PaneEntry } from '../types.js';
 import { ExitCodes } from '../exits.js';
 import { loadLocalConfigFile, saveLocalConfigFile } from '../config.js';
+import { getRegistryScope, registrationFromEntry } from '../registry.js';
 
 export function cmdUpdate(
   ctx: Context,
   name: string,
   options: { pane?: string; remark?: string }
 ): void {
-  const { ui, config, paths, flags, exit } = ctx;
+  const { ui, config, paths, flags, tmux, exit } = ctx;
 
   if (!config.paneRegistry[name]) {
     ui.error(`Agent '${name}' not found. Use 'tmux-team add' to create.`);
@@ -23,22 +24,18 @@ export function cmdUpdate(
     exit(ExitCodes.ERROR);
   }
 
-  // Load existing config to preserve all fields (preamble, deny, etc.)
-  const localConfig = loadLocalConfigFile(paths);
-
-  // Handle edge case where local config was modified externally
-  let entry = localConfig[name] as PaneEntry | undefined;
-  if (!entry) {
-    // Fall back to in-memory paneRegistry if entry is missing
-    entry = { ...config.paneRegistry[name] };
-    localConfig[name] = entry;
-  }
+  let entry: PaneEntry = { ...config.paneRegistry[name] };
 
   const updates: string[] = [];
 
   if (options.pane) {
-    entry.pane = options.pane;
-    updates.push(`pane → ${options.pane}`);
+    const resolvedPane = tmux.resolvePaneTarget(options.pane);
+    if (!resolvedPane) {
+      ui.error(`Pane '${options.pane}' not found. Is tmux running?`);
+      exit(ExitCodes.PANE_NOT_FOUND);
+    }
+    entry.pane = resolvedPane as string;
+    updates.push(`pane → ${entry.pane}`);
   }
 
   if (options.remark) {
@@ -46,7 +43,21 @@ export function cmdUpdate(
     updates.push(`remark updated`);
   }
 
-  saveLocalConfigFile(paths, localConfig);
+  const canonicalPane = tmux.resolvePaneTarget(entry.pane);
+  if (!canonicalPane) {
+    ui.error(`Pane '${entry.pane}' not found. Is tmux running?`);
+    exit(ExitCodes.PANE_NOT_FOUND);
+  }
+  entry.pane = canonicalPane as string;
+
+  const scope = getRegistryScope(ctx);
+  const updatedLegacy = updateLegacyEntryIfPresent(paths, name, entry);
+  const removed = options.pane ? tmux.clearAgentRegistration(name, scope) : false;
+  tmux.setAgentRegistration(entry.pane, scope, registrationFromEntry(name, entry));
+
+  if (updatedLegacy && removed) {
+    pruneLegacyEntry(paths, name);
+  }
 
   if (flags.json) {
     ui.json({ updated: name, ...options });
@@ -56,3 +67,23 @@ export function cmdUpdate(
     }
   }
 }
+
+function updateLegacyEntryIfPresent(
+  paths: Context['paths'],
+  name: string,
+  entry: PaneEntry
+): boolean {
+  const localConfig = loadLocalConfigFile(paths);
+  if (!localConfig[name]) return false;
+
+  localConfig[name] = { ...entry };
+  saveLocalConfigFile(paths, localConfig);
+  return true;
+}
+
+function pruneLegacyEntry(paths: Context['paths'], name: string): void {
+  const localConfig = loadLocalConfigFile(paths);
+  if (!localConfig[name]) return;
+  delete localConfig[name];
+  saveLocalConfigFile(paths, localConfig);
+}

package/src/config.test.ts

@@ -246,6 +246,30 @@ describe('loadConfig', () => {
     expect(config.paneRegistry.codex?.pane).toBe('1.1');
   });
 
+  it('overlays tmux registry on top of legacy local entries', () => {
+    const localConfig = {
+      claude: { pane: '1.0', remark: 'legacy' },
+      codex: { pane: '1.1', remark: 'legacy codex' },
+    };
+
+    vi.mocked(fs.existsSync).mockImplementation((p) => p === mockPaths.localConfig);
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(localConfig));
+
+    const config = loadConfig(mockPaths, {
+      paneRegistry: {
+        claude: { pane: '%9', remark: 'tmux' },
+      },
+      agents: {
+        claude: { preamble: 'from tmux' },
+      },
+    });
+
+    expect(config.registrySource).toBe('tmux');
+    expect(config.paneRegistry.claude).toEqual({ pane: '%9', remark: 'tmux' });
+    expect(config.paneRegistry.codex).toEqual({ pane: '1.1', remark: 'legacy codex' });
+    expect(config.agents.claude?.preamble).toBe('from tmux');
+  });
+
   it('merges both global and local config (agents from local only)', () => {
     const globalConfig = {
       mode: 'wait',

package/src/config.ts

@@ -12,6 +12,7 @@ import type {
   LocalSettings,
   ResolvedConfig,
   Paths,
+  TmuxRegistry,
 } from './types.js';
 
 const CONFIG_FILENAME = 'config.json';
@@ -103,6 +104,27 @@ function findUpward(filename: string, startDir: string): string | null {
   }
 }
 
+/**
+ * Resolve the workspace scope used for default registrations.
+ *
+ * Prefer the nearest Git root so commands run from subdirectories share the
+ * same default team. Fall back to cwd for non-Git folders.
+ */
+export function resolveWorkspaceRoot(cwd: string = process.cwd()): string {
+  let dir = path.resolve(cwd);
+  while (true) {
+    const gitPath = path.join(dir, '.git');
+    if (fs.existsSync(gitPath)) {
+      return dir;
+    }
+    const parent = path.dirname(dir);
+    if (parent === dir) {
+      return path.resolve(cwd);
+    }
+    dir = parent;
+  }
+}
+
 /**
  * Get the path to a shared team config file.
  */
@@ -122,6 +144,7 @@ export function ensureTeamsDir(globalDir: string): void {
 
 export function resolvePaths(cwd: string = process.cwd(), teamName?: string): Paths {
   const globalDir = resolveGlobalDir();
+  const workspaceRoot = resolveWorkspaceRoot(cwd);
 
   // If team name is specified, use the shared team config
   if (teamName) {
@@ -131,6 +154,7 @@ export function resolvePaths(cwd: string = process.cwd(), teamName?: string): Pa
       globalConfig: path.join(globalDir, CONFIG_FILENAME),
       localConfig: teamConfig,
       stateFile: path.join(globalDir, STATE_FILENAME),
+      workspaceRoot,
     };
   }
 
@@ -143,6 +167,7 @@ export function resolvePaths(cwd: string = process.cwd(), teamName?: string): Pa
     globalConfig: path.join(globalDir, CONFIG_FILENAME),
     localConfig: localConfigPath,
     stateFile: path.join(globalDir, STATE_FILENAME),
+    workspaceRoot,
   };
 }
 
@@ -177,13 +202,14 @@ function loadJsonFile<T>(filePath: string): T | null {
  *
  * Note: CLI flags are applied by the caller after this function returns.
  */
-export function loadConfig(paths: Paths): ResolvedConfig {
+export function loadConfig(paths: Paths, tmuxRegistry?: TmuxRegistry): ResolvedConfig {
   // Start with defaults
   const config: ResolvedConfig = {
     ...DEFAULT_CONFIG,
     defaults: { ...DEFAULT_CONFIG.defaults },
     agents: {},
     paneRegistry: {},
+    registrySource: 'none',
   };
 
   // Merge global config (mode, preambleMode, defaults only)
@@ -196,8 +222,9 @@ export function loadConfig(paths: Paths): ResolvedConfig {
     }
   }
 
-  // Load local config (pane registry + optional settings + agent config)
-  // Local config is the SSOT for agent configuration (preamble, deny)
+  // Load local config (legacy pane registry + optional settings + agent config).
+  // Runtime agent registration now prefers tmux pane metadata; local pane entries
+  // remain as a compatibility fallback when no tmux metadata exists for the scope.
   const localConfigFile = loadJsonFile<LocalConfigFile>(paths.localConfig);
   if (localConfigFile) {
     // Extract local settings if present
@@ -222,6 +249,7 @@ export function loadConfig(paths: Paths): ResolvedConfig {
       // Add to pane registry if has valid pane field
       if (paneEntry.pane) {
         config.paneRegistry[agentName] = paneEntry;
+        config.registrySource = 'legacy';
       }
 
       // Build agents config from preamble/deny fields
@@ -237,6 +265,12 @@ export function loadConfig(paths: Paths): ResolvedConfig {
     }
   }
 
+  if (tmuxRegistry && Object.keys(tmuxRegistry.paneRegistry).length > 0) {
+    config.paneRegistry = { ...config.paneRegistry, ...tmuxRegistry.paneRegistry };
+    config.agents = { ...config.agents, ...tmuxRegistry.agents };
+    config.registrySource = 'tmux';
+  }
+
   return config;
 }
 

package/src/context.test.ts

@@ -18,7 +18,14 @@ describe('createContext', () => {
     const config: ResolvedConfig = {
       mode: 'polling',
       preambleMode: 'always',
-      defaults: { timeout: 180, pollInterval: 1, captureLines: 100, maxCaptureLines: 2000, preambleEvery: 3, pasteEnterDelayMs: 500 },
+      defaults: {
+        timeout: 180,
+        pollInterval: 1,
+        captureLines: 100,
+        maxCaptureLines: 2000,
+        preambleEvery: 3,
+        pasteEnterDelayMs: 500,
+      },
       agents: {},
       paneRegistry: {},
     };
@@ -35,6 +42,13 @@ describe('createContext', () => {
       capture: vi.fn(),
       listPanes: vi.fn(() => []),
       getCurrentPaneId: vi.fn(() => null),
+      resolvePaneTarget: vi.fn((target: string) => target),
+      getAgentRegistry: vi.fn(() => ({ paneRegistry: {}, agents: {} })),
+      setAgentRegistration: vi.fn(),
+      clearAgentRegistration: vi.fn(() => false),
+      listTeams: vi.fn(() => ({})),
+      listTeamPanes: vi.fn(() => []),
+      removeTeam: vi.fn(() => ({ removed: 0, agents: [] })),
     };
 
     vi.doMock('./config.js', () => ({
@@ -54,6 +68,67 @@ describe('createContext', () => {
     expect(ctx.tmux).toBe(tmux);
   });
 
+  it('uses team registry scope when --team is set', async () => {
+    vi.resetModules();
+
+    const paths: Paths = {
+      globalDir: '/g',
+      globalConfig: '/g/config.json',
+      localConfig: '/g/teams/egp.json',
+      stateFile: '/g/state.json',
+      workspaceRoot: '/repo',
+    };
+    const config: ResolvedConfig = {
+      mode: 'polling',
+      preambleMode: 'always',
+      defaults: {
+        timeout: 180,
+        pollInterval: 1,
+        captureLines: 100,
+        maxCaptureLines: 2000,
+        preambleEvery: 3,
+        pasteEnterDelayMs: 500,
+      },
+      agents: {},
+      paneRegistry: {},
+    };
+    const tmux: Tmux = {
+      send: vi.fn(),
+      capture: vi.fn(),
+      listPanes: vi.fn(() => []),
+      getCurrentPaneId: vi.fn(() => null),
+      resolvePaneTarget: vi.fn((target: string) => target),
+      getAgentRegistry: vi.fn(() => ({ paneRegistry: {}, agents: {} })),
+      setAgentRegistration: vi.fn(),
+      clearAgentRegistration: vi.fn(() => false),
+      listTeams: vi.fn(() => ({})),
+      listTeamPanes: vi.fn(() => []),
+      removeTeam: vi.fn(() => ({ removed: 0, agents: [] })),
+    };
+
+    vi.doMock('./config.js', () => ({
+      resolvePaths: () => paths,
+      loadConfig: () => config,
+    }));
+    vi.doMock('./ui.js', () => ({
+      createUI: () => ({
+        info: vi.fn(),
+        success: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        table: vi.fn(),
+        json: vi.fn(),
+      }),
+    }));
+    vi.doMock('./tmux.js', () => ({ createTmux: () => tmux }));
+
+    const { createContext } = await import('./context.js');
+    const ctx = createContext({ argv: [], flags: { json: false, verbose: false, team: 'egp' } });
+
+    expect(ctx.registryScope).toEqual({ type: 'team', teamName: 'egp' });
+    expect(tmux.getAgentRegistry).toHaveBeenCalledWith({ type: 'team', teamName: 'egp' });
+  });
+
   it('ctx.exit calls process.exit', async () => {
     vi.resetModules();
     const exitSpy = vi.spyOn(process, 'exit').mockImplementation(((code?: number) => {