tmux-team 4.0.0 → 4.2.0

package/src/commands/basic-commands.test.ts

@@ -17,6 +17,8 @@ import { cmdConfig } from './config.js';
 import { cmdCompletion } from './completion.js';
 import { cmdHelp } from './help.js';
 import { cmdLearn } from './learn.js';
+import { cmdMigrate } from './migrate.js';
+import { cmdTeam } from './team.js';
 
 function createMockUI(): UI & { jsonCalls: unknown[] } {
   return {
@@ -38,6 +40,13 @@ function createMockTmux(): Tmux {
     capture: vi.fn(() => 'captured'),
     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: [] })),
   };
 }
 
@@ -54,7 +63,14 @@ function createCtx(
   const baseConfig: 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: {},
     ...overrides?.config,
@@ -107,12 +123,14 @@ describe('basic commands', () => {
     expect((ctx.ui as any).jsonCalls[0]).toMatchObject({ created: ctx.paths.localConfig });
   });
 
-  it('cmdAdd creates config if missing and writes new agent', () => {
+  it('cmdAdd writes new agent to tmux metadata', () => {
     const ctx = createCtx(testDir);
     cmdAdd(ctx, 'codex', '1.1', 'review');
-    const saved = JSON.parse(fs.readFileSync(ctx.paths.localConfig, 'utf-8'));
-    expect(saved.codex.pane).toBe('1.1');
-    expect(saved.codex.remark).toBe('review');
+    expect(ctx.tmux.setAgentRegistration).toHaveBeenCalledWith(
+      '1.1',
+      expect.objectContaining({ type: 'workspace' }),
+      { name: 'codex', remark: 'review' }
+    );
   });
 
   it('cmdAdd errors if agent exists', () => {
@@ -125,9 +143,11 @@ describe('basic commands', () => {
     const ctx = createCtx(testDir);
     (ctx.tmux.getCurrentPaneId as ReturnType<typeof vi.fn>).mockReturnValue('%5');
     cmdThis(ctx, 'myagent', 'test remark');
-    const saved = JSON.parse(fs.readFileSync(ctx.paths.localConfig, 'utf-8'));
-    expect(saved.myagent.pane).toBe('%5');
-    expect(saved.myagent.remark).toBe('test remark');
+    expect(ctx.tmux.setAgentRegistration).toHaveBeenCalledWith(
+      '%5',
+      expect.objectContaining({ type: 'workspace' }),
+      { name: 'myagent', remark: 'test remark' }
+    );
   });
 
   it('cmdThis errors when not in tmux', () => {
@@ -166,22 +186,32 @@ describe('basic commands', () => {
     });
     fs.writeFileSync(ctx.paths.localConfig, JSON.stringify({ codex: { pane: '1.1' } }, null, 2));
     cmdRemove(ctx, 'codex');
-    expect((ctx.ui as any).jsonCalls).toEqual([{ removed: 'codex' }]);
+    expect((ctx.ui as any).jsonCalls).toEqual([{ removed: 'codex', source: 'legacy' }]);
   });
 
-  it('cmdUpdate updates pane and remark; creates entry if missing', () => {
+  it('cmdUpdate updates pane and remark in tmux metadata', () => {
     const ctx = createCtx(testDir, { config: { paneRegistry: { codex: { pane: '1.1' } } } });
     fs.writeFileSync(ctx.paths.localConfig, JSON.stringify({}, null, 2));
     cmdUpdate(ctx, 'codex', { pane: '2.2', remark: 'new' });
-    const saved = JSON.parse(fs.readFileSync(ctx.paths.localConfig, 'utf-8'));
-    expect(saved.codex.pane).toBe('2.2');
-    expect(saved.codex.remark).toBe('new');
+    expect(ctx.tmux.clearAgentRegistration).toHaveBeenCalledWith(
+      'codex',
+      expect.objectContaining({ type: 'workspace' })
+    );
+    expect(ctx.tmux.setAgentRegistration).toHaveBeenCalledWith(
+      '2.2',
+      expect.objectContaining({ type: 'workspace' }),
+      { name: 'codex', remark: 'new' }
+    );
   });
 
   it('cmdUpdate errors when agent not found', () => {
     const ctx = createCtx(testDir);
-    expect(() => cmdUpdate(ctx, 'notfound', { pane: '1.0' })).toThrow(`exit(${ExitCodes.PANE_NOT_FOUND})`);
-    expect(ctx.ui.error).toHaveBeenCalledWith("Agent 'notfound' not found. Use 'tmux-team add' to create.");
+    expect(() => cmdUpdate(ctx, 'notfound', { pane: '1.0' })).toThrow(
+      `exit(${ExitCodes.PANE_NOT_FOUND})`
+    );
+    expect(ctx.ui.error).toHaveBeenCalledWith(
+      "Agent 'notfound' not found. Use 'tmux-team add' to create."
+    );
   });
 
   it('cmdUpdate errors when no updates specified', () => {
@@ -197,7 +227,9 @@ describe('basic commands', () => {
     });
     fs.writeFileSync(ctx.paths.localConfig, JSON.stringify({ codex: { pane: '1.1' } }, null, 2));
     cmdUpdate(ctx, 'codex', { pane: '2.0', remark: 'updated' });
-    expect((ctx.ui as any).jsonCalls).toEqual([{ updated: 'codex', pane: '2.0', remark: 'updated' }]);
+    expect((ctx.ui as any).jsonCalls).toEqual([
+      { updated: 'codex', pane: '2.0', remark: 'updated' },
+    ]);
   });
 
   it('cmdList outputs JSON when --json', () => {
@@ -215,6 +247,14 @@ describe('basic commands', () => {
     expect(ctx.ui.info).toHaveBeenCalled();
   });
 
+  it('cmdList prints team hint when no shared team agents exist', () => {
+    const ctx = createCtx(testDir, { flags: { team: 'egp' } });
+    cmdList(ctx);
+    expect(ctx.ui.info).toHaveBeenCalledWith(
+      'No agents in team "egp". Use \'tmt this <name> --team egp\' to add one.'
+    );
+  });
+
   it('cmdList prints table when agents exist', () => {
     const ctx = createCtx(testDir, {
       config: { paneRegistry: { claude: { pane: '1.0', remark: 'main' } } },
@@ -223,6 +263,16 @@ describe('basic commands', () => {
     expect(ctx.ui.table).toHaveBeenCalled();
   });
 
+  it('cmdList warns when using legacy registry', () => {
+    const ctx = createCtx(testDir, {
+      config: { paneRegistry: { claude: { pane: '1.0' } }, registrySource: 'legacy' },
+    });
+    cmdList(ctx);
+    expect(ctx.ui.warn).toHaveBeenCalledWith(
+      'Using legacy tmux-team.json registry. Run `tmt migrate` to store registrations in tmux.'
+    );
+  });
+
   it('cmdList shows dash for missing remark', () => {
     const ctx = createCtx(testDir, {
       config: { paneRegistry: { claude: { pane: '1.0' } } }, // no remark
@@ -234,6 +284,98 @@ describe('basic commands', () => {
     expect(tableCall[1][0][2]).toBe('-');
   });
 
+  it('cmdList can list a shared team by positional name', () => {
+    const ctx = createCtx(testDir);
+    (ctx.tmux.listTeams as ReturnType<typeof vi.fn>).mockReturnValue({ egp: ['claude'] });
+    (ctx.tmux.listTeamPanes as ReturnType<typeof vi.fn>).mockReturnValue([
+      {
+        pane: '%1',
+        target: 'main:1.0',
+        cwd: '/repo',
+        command: 'claude',
+        suggestedName: 'claude',
+        registrations: [{ scopeType: 'team', scope: 'egp', agent: 'claude' }],
+      },
+    ]);
+
+    cmdList(ctx, 'egp');
+
+    expect(ctx.ui.table).toHaveBeenCalledWith(
+      ['NAME', 'PANE', 'TARGET', 'CWD', 'CMD', 'REMARK'],
+      [['claude', '%1', 'main:1.0', '/repo', 'claude', '-']]
+    );
+  });
+
+  it('cmdList can show pane status by pane target', () => {
+    const ctx = createCtx(testDir);
+    (ctx.tmux.resolvePaneTarget as ReturnType<typeof vi.fn>).mockImplementation((target: string) =>
+      target === 'main:1.0' ? '%1' : null
+    );
+    (ctx.tmux.listTeamPanes as ReturnType<typeof vi.fn>).mockReturnValue([
+      {
+        pane: '%1',
+        target: 'main:1.0',
+        cwd: '/repo',
+        command: 'claude',
+        suggestedName: 'claude',
+        registrations: [
+          { scopeType: 'workspace', scope: '/repo', agent: 'claude' },
+          { scopeType: 'team', scope: 'egp', agent: 'reviewer', remark: 'strict' },
+        ],
+      },
+    ]);
+
+    cmdList(ctx, 'main.1.0');
+
+    expect(ctx.tmux.resolvePaneTarget).toHaveBeenCalledWith('main.1.0');
+    expect(ctx.tmux.resolvePaneTarget).toHaveBeenCalledWith('main:1.0');
+    expect(ctx.ui.table).toHaveBeenCalledWith(
+      ['SCOPE', 'NAME', 'REMARK'],
+      [
+        ['workspace:/repo', 'claude', '-'],
+        ['team:egp', 'reviewer', 'strict'],
+      ]
+    );
+  });
+
+  it('cmdList outputs pane status JSON and handles unregistered panes', () => {
+    const ctx = createCtx(testDir, { flags: { json: true } });
+    (ctx.tmux.resolvePaneTarget as ReturnType<typeof vi.fn>).mockReturnValue('%9');
+    (ctx.tmux.listTeamPanes as ReturnType<typeof vi.fn>).mockReturnValue([
+      {
+        pane: '%9',
+        target: 'main:9.0',
+        cwd: '/tmp',
+        command: 'zsh',
+        suggestedName: null,
+        registrations: [],
+      },
+    ]);
+
+    cmdList(ctx, '9.0');
+
+    expect((ctx.ui as any).jsonCalls).toEqual([
+      {
+        pane: {
+          pane: '%9',
+          target: 'main:9.0',
+          cwd: '/tmp',
+          command: 'zsh',
+          suggestedName: null,
+          registrations: [],
+        },
+      },
+    ]);
+  });
+
+  it('cmdList errors when positional target is neither team nor pane', () => {
+    const ctx = createCtx(testDir);
+    (ctx.tmux.resolvePaneTarget as ReturnType<typeof vi.fn>).mockReturnValue(null);
+
+    expect(() => cmdList(ctx, 'missing')).toThrow(`exit(${ExitCodes.PANE_NOT_FOUND})`);
+    expect(ctx.ui.error).toHaveBeenCalledWith("Pane or team 'missing' not found.");
+  });
+
   it('cmdCheck captures pane output', () => {
     const ctx = createCtx(testDir, {
       config: { paneRegistry: { claude: { pane: '1.0' } } },
@@ -249,6 +391,31 @@ describe('basic commands', () => {
     expect(() => cmdCheck(ctx, 'nope')).toThrow(`exit(${ExitCodes.PANE_NOT_FOUND})`);
   });
 
+  it('cmdCheck points at shared teams when a missing agent is only registered there', () => {
+    const ctx = createCtx(testDir);
+    (ctx.tmux.listTeams as ReturnType<typeof vi.fn>).mockReturnValue({
+      alpha: ['codex'],
+      beta: ['codex'],
+    });
+
+    expect(() => cmdCheck(ctx, 'codex')).toThrow(`exit(${ExitCodes.PANE_NOT_FOUND})`);
+    expect(ctx.ui.error).toHaveBeenCalledWith(
+      "Agent 'codex' is in multiple shared teams: alpha, beta. Specify one with --team <team>."
+    );
+  });
+
+  it('cmdCheck points at the single shared team when there is no ambiguity', () => {
+    const ctx = createCtx(testDir);
+    (ctx.tmux.listTeams as ReturnType<typeof vi.fn>).mockReturnValue({
+      alpha: ['codex'],
+    });
+
+    expect(() => cmdCheck(ctx, 'codex')).toThrow(`exit(${ExitCodes.PANE_NOT_FOUND})`);
+    expect(ctx.ui.error).toHaveBeenCalledWith(
+      "Agent 'codex' is in shared team 'alpha'. Specify it: tmt check codex --team alpha"
+    );
+  });
+
   it('cmdCheck errors when tmux capture fails', () => {
     const ctx = createCtx(testDir, {
       config: { paneRegistry: { claude: { pane: '1.0' } } },
@@ -327,7 +494,9 @@ describe('basic commands', () => {
   it('cmdConfig set errors when not enough args', () => {
     const ctx = createCtx(testDir);
     expect(() => cmdConfig(ctx, ['set', 'mode'])).toThrow(`exit(${ExitCodes.ERROR})`);
-    expect(ctx.ui.error).toHaveBeenCalledWith('Usage: tmux-team config set <key> <value> [--global]');
+    expect(ctx.ui.error).toHaveBeenCalledWith(
+      'Usage: tmux-team config set <key> <value> [--global]'
+    );
   });
 
   it('cmdConfig errors on unknown subcommand', () => {
@@ -360,6 +529,354 @@ describe('basic commands', () => {
     );
   });
 
+  it('cmdMigrate dry-run reports legacy entries without writing tmux metadata', () => {
+    const ctx = createCtx(testDir, { flags: { json: true } });
+    fs.writeFileSync(
+      ctx.paths.localConfig,
+      JSON.stringify({ claude: { pane: '1.1', remark: 'review' } }, null, 2)
+    );
+
+    cmdMigrate(ctx, ['--dry-run']);
+
+    expect(ctx.tmux.setAgentRegistration).not.toHaveBeenCalled();
+    expect((ctx.ui as any).jsonCalls[0]).toMatchObject({
+      dryRun: true,
+      migrated: 0,
+      items: [{ agent: 'claude', fromPane: '1.1', pane: '1.1', status: 'ready' }],
+    });
+  });
+
+  it('cmdMigrate writes tmux metadata and can clean legacy entries', () => {
+    const ctx = createCtx(testDir);
+    fs.writeFileSync(
+      ctx.paths.localConfig,
+      JSON.stringify({
+        $config: { mode: 'wait' },
+        claude: { pane: '1.1', remark: 'review', preamble: 'Be helpful' },
+      })
+    );
+
+    cmdMigrate(ctx, ['--cleanup']);
+
+    expect(ctx.tmux.setAgentRegistration).toHaveBeenCalledWith(
+      '1.1',
+      expect.objectContaining({ type: 'workspace' }),
+      { name: 'claude', remark: 'review', preamble: 'Be helpful' }
+    );
+    const saved = JSON.parse(fs.readFileSync(ctx.paths.localConfig, 'utf-8'));
+    expect(saved.$config.mode).toBe('wait');
+    expect(saved.claude).toBeUndefined();
+  });
+
+  it('cmdMigrate errors when a legacy pane cannot be resolved', () => {
+    const ctx = createCtx(testDir);
+    (ctx.tmux.resolvePaneTarget as ReturnType<typeof vi.fn>).mockReturnValue(null);
+    fs.writeFileSync(ctx.paths.localConfig, JSON.stringify({ claude: { pane: 'missing' } }));
+
+    expect(() => cmdMigrate(ctx, [])).toThrow(`exit(${ExitCodes.PANE_NOT_FOUND})`);
+  });
+
+  it('cmdMigrate reports when no legacy agents exist', () => {
+    const ctx = createCtx(testDir);
+    fs.writeFileSync(ctx.paths.localConfig, JSON.stringify({ $config: { mode: 'wait' } }));
+
+    cmdMigrate(ctx, []);
+
+    expect(ctx.ui.info).toHaveBeenCalledWith(`No legacy agents found in ${ctx.paths.localConfig}`);
+  });
+
+  it('cmdTeam lists team names by default', () => {
+    const ctx = createCtx(testDir, { flags: { json: true } });
+    (ctx.tmux.listTeams as ReturnType<typeof vi.fn>).mockReturnValue({
+      egp: ['claude', 'codex'],
+    });
+
+    cmdTeam(ctx, []);
+
+    expect((ctx.ui as any).jsonCalls).toEqual([{ teams: { egp: ['claude', 'codex'] } }]);
+  });
+
+  it('cmdTeam panes lists all pane team/workspace scopes', () => {
+    const ctx = createCtx(testDir, { flags: { json: true } });
+    (ctx.tmux.listTeams as ReturnType<typeof vi.fn>).mockReturnValue({
+      egp: ['claude', 'codex'],
+    });
+    (ctx.tmux.listTeamPanes as ReturnType<typeof vi.fn>).mockReturnValue([
+      {
+        pane: '%1',
+        target: 'main:1.0',
+        cwd: '/repo',
+        command: 'claude',
+        suggestedName: 'claude',
+        registrations: [
+          { scopeType: 'workspace', scope: '/repo', agent: 'claude', remark: 'lead' },
+          { scopeType: 'team', scope: 'egp', agent: 'claude' },
+        ],
+      },
+    ]);
+
+    cmdTeam(ctx, ['panes']);
+
+    expect((ctx.ui as any).jsonCalls).toEqual([
+      {
+        teams: { egp: ['claude', 'codex'] },
+        panes: [
+          {
+            pane: '%1',
+            target: 'main:1.0',
+            cwd: '/repo',
+            command: 'claude',
+            suggestedName: 'claude',
+            registrations: [
+              { scopeType: 'workspace', scope: '/repo', agent: 'claude', remark: 'lead' },
+              { scopeType: 'team', scope: 'egp', agent: 'claude' },
+            ],
+          },
+        ],
+      },
+    ]);
+  });
+
+  it('cmdTeam shows empty state and errors on unknown subcommands', () => {
+    const ctx = createCtx(testDir);
+
+    cmdTeam(ctx, []);
+    expect(ctx.ui.info).toHaveBeenCalledWith('No shared teams found.');
+
+    expect(() => cmdTeam(ctx, ['wat'])).toThrow(`exit(${ExitCodes.ERROR})`);
+  });
+
+  it('cmdTeam summary keeps shared-team aggregate view', () => {
+    const ctx = createCtx(testDir);
+    (ctx.tmux.listTeams as ReturnType<typeof vi.fn>).mockReturnValue({ egp: ['claude'] });
+
+    cmdTeam(ctx, ['ls', '--summary']);
+
+    expect(ctx.ui.table).toHaveBeenCalledWith(['TEAM', 'AGENTS'], [['egp', 'claude']]);
+  });
+
+  it('cmdTeam ls lists members for one team', () => {
+    const ctx = createCtx(testDir);
+    (ctx.tmux.listTeamPanes as ReturnType<typeof vi.fn>).mockReturnValue([
+      {
+        pane: '%2',
+        target: 'main:2.0',
+        cwd: '/repo',
+        command: 'codex',
+        suggestedName: 'codex',
+        registrations: [{ scopeType: 'team', scope: 'egp', agent: 'codex', remark: 'review' }],
+      },
+      {
+        pane: '%1',
+        target: 'main:1.0',
+        cwd: '/repo',
+        command: 'claude',
+        suggestedName: 'claude',
+        registrations: [{ scopeType: 'team', scope: 'egp', agent: 'claude' }],
+      },
+    ]);
+
+    cmdTeam(ctx, ['ls', 'egp']);
+
+    expect(ctx.ui.table).toHaveBeenCalledWith(
+      ['NAME', 'PANE', 'TARGET', 'CWD', 'CMD', 'REMARK'],
+      [
+        ['claude', '%1', 'main:1.0', '/repo', 'claude', '-'],
+        ['codex', '%2', 'main:2.0', '/repo', 'codex', 'review'],
+      ]
+    );
+  });
+
+  it('cmdTeam ls outputs JSON and reports empty teams', () => {
+    const ctx = createCtx(testDir, { flags: { json: true } });
+    (ctx.tmux.listTeamPanes as ReturnType<typeof vi.fn>).mockReturnValue([]);
+
+    cmdTeam(ctx, ['ls', 'missing']);
+
+    expect((ctx.ui as any).jsonCalls).toEqual([{ team: 'missing', members: [] }]);
+
+    const humanCtx = createCtx(testDir);
+    cmdTeam(humanCtx, ['ls', 'missing']);
+    expect(humanCtx.ui.info).toHaveBeenCalledWith(
+      'No agents in team "missing". Use \'tmt team add missing <name>\' to add one.'
+    );
+  });
+
+  it('cmdTeam add registers current pane in a team', () => {
+    const ctx = createCtx(testDir);
+    (ctx.tmux.getCurrentPaneId as ReturnType<typeof vi.fn>).mockReturnValue('%5');
+    (ctx.tmux.resolvePaneTarget as ReturnType<typeof vi.fn>).mockReturnValue('%5');
+
+    cmdTeam(ctx, ['add', 'egp', 'claude']);
+
+    expect(ctx.tmux.setAgentRegistration).toHaveBeenCalledWith(
+      '%5',
+      { type: 'team', teamName: 'egp' },
+      { name: 'claude' }
+    );
+  });
+
+  it('cmdTeam add supports explicit panes, remarks, JSON, and duplicate errors', () => {
+    const ctx = createCtx(testDir, { flags: { json: true } });
+    (ctx.tmux.resolvePaneTarget as ReturnType<typeof vi.fn>).mockReturnValue('%6');
+
+    cmdTeam(ctx, ['add', 'egp', 'codex', '1.2', 'reviewer']);
+
+    expect(ctx.tmux.setAgentRegistration).toHaveBeenCalledWith(
+      '%6',
+      { type: 'team', teamName: 'egp' },
+      { name: 'codex', remark: 'reviewer' }
+    );
+    expect((ctx.ui as any).jsonCalls).toEqual([
+      { added: 'codex', team: 'egp', pane: '%6', remark: 'reviewer' },
+    ]);
+
+    const duplicateCtx = createCtx(testDir);
+    (duplicateCtx.tmux.getAgentRegistry as ReturnType<typeof vi.fn>).mockReturnValue({
+      paneRegistry: { codex: { pane: '%6' } },
+      agents: {},
+    });
+    expect(() => cmdTeam(duplicateCtx, ['add', 'egp', 'codex', '1.2'])).toThrow(
+      `exit(${ExitCodes.ERROR})`
+    );
+  });
+
+  it('cmdTeam add requires a pane when outside tmux', () => {
+    const ctx = createCtx(testDir);
+
+    expect(() => cmdTeam(ctx, ['add', 'egp', 'codex'])).toThrow(`exit(${ExitCodes.ERROR})`);
+    expect(ctx.ui.error).toHaveBeenCalledWith(
+      'Not running inside tmux. Provide a pane target: tmt team add <team> <name> <pane>'
+    );
+  });
+
+  it('cmdTeam add validates arguments and pane targets', () => {
+    const ctx = createCtx(testDir);
+    expect(() => cmdTeam(ctx, ['add', 'egp'])).toThrow(`exit(${ExitCodes.ERROR})`);
+    expect(ctx.ui.error).toHaveBeenCalledWith(
+      'Usage: tmux-team team add <team> <name> [pane] [remark]'
+    );
+
+    const paneCtx = createCtx(testDir);
+    (paneCtx.tmux.resolvePaneTarget as ReturnType<typeof vi.fn>).mockReturnValue(null);
+    expect(() => cmdTeam(paneCtx, ['add', 'egp', 'codex', 'missing'])).toThrow(
+      `exit(${ExitCodes.PANE_NOT_FOUND})`
+    );
+    expect(paneCtx.ui.error).toHaveBeenCalledWith("Pane 'missing' not found. Is tmux running?");
+  });
+
+  it('cmdTeam panes table groups by team/workspace scope before pane order', () => {
+    const ctx = createCtx(testDir);
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    (ctx.tmux.listTeamPanes as ReturnType<typeof vi.fn>).mockReturnValue([
+      {
+        pane: '%3',
+        target: 'main:3.0',
+        cwd: '/tmp',
+        command: 'zsh',
+        suggestedName: null,
+        registrations: [],
+      },
+      {
+        pane: '%1',
+        target: 'main:1.0',
+        cwd: '/repo',
+        command: 'claude',
+        suggestedName: 'claude',
+        registrations: [{ scopeType: 'workspace', scope: '/repo', agent: 'claude' }],
+      },
+      {
+        pane: '%2',
+        target: 'main:2.0',
+        cwd: '/repo',
+        command: 'codex',
+        suggestedName: 'codex',
+        registrations: [{ scopeType: 'team', scope: 'beta', agent: 'codex' }],
+      },
+      {
+        pane: '%4',
+        target: 'main:4.0',
+        cwd: '/repo',
+        command: 'gemini',
+        suggestedName: 'gemini',
+        registrations: [{ scopeType: 'team', scope: 'alpha', agent: 'gemini' }],
+      },
+    ]);
+
+    cmdTeam(ctx, ['panes']);
+
+    expect(logSpy.mock.calls.map((call) => call[0])).toEqual([
+      'Team: alpha (gemini)',
+      '',
+      'Team: beta (codex)',
+      '',
+      'Workspace: /repo (claude)',
+      '',
+      'Unregistered panes',
+    ]);
+    expect((ctx.ui.table as ReturnType<typeof vi.fn>).mock.calls.map((call) => call[0])).toEqual([
+      ['PANE', 'TARGET', 'CWD', 'CMD'],
+      ['PANE', 'TARGET', 'CWD', 'CMD'],
+      ['PANE', 'TARGET', 'CWD', 'CMD'],
+      ['PANE', 'TARGET', 'CWD', 'CMD'],
+    ]);
+    expect((ctx.ui.table as ReturnType<typeof vi.fn>).mock.calls[0][1]).toEqual([
+      ['%4', 'main:4.0', '/repo', 'gemini'],
+    ]);
+    logSpy.mockRestore();
+  });
+
+  it('cmdTeam rm supports dry-run and force removal', () => {
+    const ctx = createCtx(testDir);
+    (ctx.tmux.listTeams as ReturnType<typeof vi.fn>).mockReturnValue({
+      egp: ['claude'],
+    });
+    (ctx.tmux.removeTeam as ReturnType<typeof vi.fn>).mockReturnValue({
+      removed: 1,
+      agents: ['claude'],
+    });
+
+    cmdTeam(ctx, ['rm', 'egp', '--dry-run']);
+    expect(ctx.tmux.removeTeam).not.toHaveBeenCalled();
+
+    ctx.flags.force = true;
+    cmdTeam(ctx, ['rm', 'egp']);
+    expect(ctx.tmux.removeTeam).toHaveBeenCalledWith('egp');
+  });
+
+  it('cmdTeam rm requires --force and errors for missing teams', () => {
+    const ctx = createCtx(testDir);
+    (ctx.tmux.listTeams as ReturnType<typeof vi.fn>).mockReturnValue({ egp: ['claude'] });
+
+    expect(() => cmdTeam(ctx, ['rm'])).toThrow(`exit(${ExitCodes.ERROR})`);
+    expect(ctx.ui.error).toHaveBeenCalledWith('Usage: tmux-team team rm <team> --force');
+
+    expect(() => cmdTeam(ctx, ['rm', 'egp'])).toThrow(`exit(${ExitCodes.ERROR})`);
+
+    (ctx.tmux.listTeams as ReturnType<typeof vi.fn>).mockReturnValue({});
+    expect(() => cmdTeam(ctx, ['rm', 'missing', '--force'])).toThrow(
+      `exit(${ExitCodes.PANE_NOT_FOUND})`
+    );
+  });
+
+  it('cmdTeam rm outputs JSON in dry-run and force modes', () => {
+    const ctx = createCtx(testDir, { flags: { json: true } });
+    (ctx.tmux.listTeams as ReturnType<typeof vi.fn>).mockReturnValue({ egp: ['claude'] });
+    (ctx.tmux.removeTeam as ReturnType<typeof vi.fn>).mockReturnValue({
+      removed: 1,
+      agents: ['claude'],
+    });
+
+    cmdTeam(ctx, ['rm', 'egp', '--dry-run']);
+    ctx.flags.force = true;
+    cmdTeam(ctx, ['rm', 'egp']);
+
+    expect((ctx.ui as any).jsonCalls).toEqual([
+      { team: 'egp', dryRun: true, agents: ['claude'], removed: 0 },
+      { team: 'egp', removed: 1, agents: ['claude'] },
+    ]);
+  });
+
   it('cmdCompletion prints scripts', () => {
     const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
     cmdCompletion('bash');

package/src/commands/check.ts

@@ -6,11 +6,31 @@ import type { Context } from '../types.js';
 import { ExitCodes } from '../exits.js';
 import { colors } from '../ui.js';
 
+function teamHintForMissingAgent(ctx: Context, target: string): string | null {
+  if (ctx.flags.team) return null;
+
+  const matches = Object.entries(ctx.tmux.listTeams())
+    .filter(([, agents]) => agents.includes(target))
+    .map(([teamName]) => teamName)
+    .sort();
+
+  if (matches.length === 0) return null;
+  if (matches.length === 1) {
+    return `Agent '${target}' is in shared team '${matches[0]}'. Specify it: tmt check ${target} --team ${matches[0]}`;
+  }
+  return `Agent '${target}' is in multiple shared teams: ${matches.join(', ')}. Specify one with --team <team>.`;
+}
+
 export function cmdCheck(ctx: Context, target: string, lines?: number): void {
   const { ui, config, tmux, flags, exit } = ctx;
 
   if (!config.paneRegistry[target]) {
     const available = Object.keys(config.paneRegistry).join(', ');
+    const teamHint = teamHintForMissingAgent(ctx, target);
+    if (teamHint) {
+      ui.error(teamHint);
+      exit(ExitCodes.PANE_NOT_FOUND);
+    }
     ui.error(`Agent '${target}' not found. Available: ${available || 'none'}`);
     exit(ExitCodes.PANE_NOT_FOUND);
   }