tmux-team 2.0.0-alpha.4 → 2.2.0

package/src/config.ts

@@ -19,15 +19,16 @@ const LOCAL_CONFIG_FILENAME = 'tmux-team.json';
 const STATE_FILENAME = 'state.json';
 
 // Default configuration values
-const DEFAULT_CONFIG: Omit<GlobalConfig, 'agents'> & { agents: Record<string, never> } = {
+const DEFAULT_CONFIG: GlobalConfig = {
   mode: 'polling',
   preambleMode: 'always',
   defaults: {
     timeout: 180,
     pollInterval: 1,
     captureLines: 100,
+    preambleEvery: 3, // inject preamble every 3 messages
+    hideOrphanTasks: false, // hide tasks without milestone in list
   },
-  agents: {},
 };
 
 /**
@@ -130,7 +131,7 @@ export function loadConfig(paths: Paths): ResolvedConfig {
     paneRegistry: {},
   };
 
-  // Merge global config
+  // Merge global config (mode, preambleMode, defaults only)
   const globalConfig = loadJsonFile<Partial<GlobalConfig>>(paths.globalConfig);
   if (globalConfig) {
     if (globalConfig.mode) config.mode = globalConfig.mode;
@@ -138,12 +139,10 @@ export function loadConfig(paths: Paths): ResolvedConfig {
     if (globalConfig.defaults) {
       config.defaults = { ...config.defaults, ...globalConfig.defaults };
     }
-    if (globalConfig.agents) {
-      config.agents = { ...config.agents, ...globalConfig.agents };
-    }
   }
 
-  // Load local config (pane registry + optional settings)
+  // Load local config (pane registry + optional settings + agent config)
+  // Local config is the SSOT for agent configuration (preamble, deny)
   const localConfigFile = loadJsonFile<LocalConfigFile>(paths.localConfig);
   if (localConfigFile) {
     // Extract local settings if present
@@ -153,22 +152,36 @@ export function loadConfig(paths: Paths): ResolvedConfig {
     if (localSettings) {
       if (localSettings.mode) config.mode = localSettings.mode;
       if (localSettings.preambleMode) config.preambleMode = localSettings.preambleMode;
+      if (localSettings.preambleEvery !== undefined) {
+        config.defaults.preambleEvery = localSettings.preambleEvery;
+      }
     }
 
-    // Set pane registry (filter out $config)
-    config.paneRegistry = paneEntries as LocalConfig;
+    // Build pane registry and agents config from local entries
+    for (const [agentName, entry] of Object.entries(paneEntries)) {
+      const paneEntry = entry as LocalConfig[string];
+
+      // Add to pane registry if has valid pane field
+      if (paneEntry.pane) {
+        config.paneRegistry[agentName] = paneEntry;
+      }
+
+      // Build agents config from preamble/deny fields
+      const hasPreamble = Object.prototype.hasOwnProperty.call(paneEntry, 'preamble');
+      const hasDeny = Object.prototype.hasOwnProperty.call(paneEntry, 'deny');
+
+      if (hasPreamble || hasDeny) {
+        config.agents[agentName] = {
+          ...(hasPreamble && { preamble: paneEntry.preamble }),
+          ...(hasDeny && { deny: paneEntry.deny }),
+        };
+      }
+    }
   }
 
   return config;
 }
 
-export function saveLocalConfig(
-  paths: Paths,
-  paneRegistry: Record<string, { pane: string; remark?: string }>
-): void {
-  fs.writeFileSync(paths.localConfig, JSON.stringify(paneRegistry, null, 2) + '\n');
-}
-
 export function ensureGlobalDir(paths: Paths): void {
   if (!fs.existsSync(paths.globalDir)) {
     fs.mkdirSync(paths.globalDir, { recursive: true });

package/src/pm/commands.test.ts

@@ -9,15 +9,7 @@ import os from 'os';
 import type { Context } from '../types.js';
 import type { UI } from '../types.js';
 // ExitCodes imported for reference but tested via ctx.exit mock
-import {
-  cmdPm,
-  cmdPmInit,
-  cmdPmMilestone,
-  cmdPmTask,
-  cmdPmDoc,
-  cmdPmLog,
-  cmdPmList,
-} from './commands.js';
+import { cmdPm, cmdPmInit, cmdPmMilestone, cmdPmTask, cmdPmLog, cmdPmList } from './commands.js';
 import { findCurrentTeamId, linkTeam, getTeamsDir } from './manager.js';
 
 // ─────────────────────────────────────────────────────────────
@@ -44,7 +36,18 @@ function createMockUI(): UI & { logs: string[]; errors: string[]; jsonData: unkn
 
 function createMockContext(
   globalDir: string,
-  options: { json?: boolean; cwd?: string; agents?: Record<string, { deny?: string[] }> } = {}
+  options: {
+    json?: boolean;
+    cwd?: string;
+    agents?: Record<string, { deny?: string[] }>;
+    defaults?: Partial<{
+      timeout: number;
+      pollInterval: number;
+      captureLines: number;
+      preambleEvery: number;
+      hideOrphanTasks: boolean;
+    }>;
+  } = {}
 ): Context & { ui: ReturnType<typeof createMockUI>; exitCode: number | null } {
   const ui = createMockUI();
   let exitCode: number | null = null;
@@ -63,7 +66,14 @@ function createMockContext(
     config: {
       mode: 'polling',
       preambleMode: 'always',
-      defaults: { timeout: 60, pollInterval: 1, captureLines: 100 },
+      defaults: {
+        timeout: 60,
+        pollInterval: 1,
+        captureLines: 100,
+        preambleEvery: 3,
+        hideOrphanTasks: false,
+        ...options.defaults,
+      },
       agents: options.agents ?? {},
       paneRegistry: {},
     },
@@ -320,9 +330,35 @@ describe('cmdPmMilestone', () => {
 
     await cmdPmMilestone(ctx, ['add', 'Phase 1']);
     await cmdPmMilestone(ctx, ['add', 'Phase 2']);
+
+    (ctx.ui.table as ReturnType<typeof vi.fn>).mockClear();
     await cmdPmMilestone(ctx, ['list']);
 
-    expect(ctx.ui.table).toHaveBeenCalled();
+    expect(ctx.ui.table).toHaveBeenCalledTimes(1);
+    expect(ctx.ui.table).toHaveBeenCalledWith(
+      ['ID', 'NAME', 'STATUS'],
+      expect.arrayContaining([
+        expect.arrayContaining(['1', 'Phase 1']),
+        expect.arrayContaining(['2', 'Phase 2']),
+      ])
+    );
+  });
+
+  it('lists milestones when called without subcommand', async () => {
+    const ctx = createMockContext(globalDir, { cwd: projectDir });
+    vi.spyOn(process, 'cwd').mockReturnValue(projectDir);
+
+    await cmdPmMilestone(ctx, ['add', 'Phase 1']);
+
+    // Clear mock call history after add, then verify empty args triggers list
+    (ctx.ui.table as ReturnType<typeof vi.fn>).mockClear();
+    await cmdPmMilestone(ctx, []);
+
+    expect(ctx.ui.table).toHaveBeenCalledTimes(1);
+    expect(ctx.ui.table).toHaveBeenCalledWith(
+      ['ID', 'NAME', 'STATUS'],
+      expect.arrayContaining([expect.arrayContaining(['1', 'Phase 1'])])
+    );
   });
 
   it('marks milestone as done', async () => {
@@ -348,6 +384,55 @@ describe('cmdPmMilestone', () => {
     expect(ctx.ui.errors[0]).toContain('not found');
   });
 
+  it('deletes milestone', async () => {
+    const ctx = createMockContext(globalDir, { cwd: projectDir });
+    vi.spyOn(process, 'cwd').mockReturnValue(projectDir);
+
+    await cmdPmMilestone(ctx, ['add', 'To Delete']);
+    await cmdPmMilestone(ctx, ['delete', '1']);
+
+    expect(ctx.ui.logs.some((l) => l.includes('deleted'))).toBe(true);
+
+    // Verify milestone was deleted
+    const milestonePath = path.join(globalDir, 'teams', teamId, 'milestones', '1.json');
+    expect(fs.existsSync(milestonePath)).toBe(false);
+  });
+
+  it('deletes milestone with rm shorthand', async () => {
+    const ctx = createMockContext(globalDir, { cwd: projectDir });
+    vi.spyOn(process, 'cwd').mockReturnValue(projectDir);
+
+    await cmdPmMilestone(ctx, ['add', 'To Remove']);
+    await cmdPmMilestone(ctx, ['rm', '1']);
+
+    expect(ctx.ui.logs.some((l) => l.includes('deleted'))).toBe(true);
+  });
+
+  it('returns JSON on milestone delete with --json flag', async () => {
+    const ctx = createMockContext(globalDir, { cwd: projectDir, json: true });
+    vi.spyOn(process, 'cwd').mockReturnValue(projectDir);
+
+    await cmdPmMilestone(ctx, ['add', 'JSON Delete']);
+    await cmdPmMilestone(ctx, ['delete', '1']);
+
+    const output = ctx.ui.jsonData[ctx.ui.jsonData.length - 1] as {
+      deleted: boolean;
+      id: string;
+      name: string;
+    };
+    expect(output.deleted).toBe(true);
+    expect(output.id).toBe('1');
+    expect(output.name).toBe('JSON Delete');
+  });
+
+  it('exits with error when deleting non-existent milestone', async () => {
+    const ctx = createMockContext(globalDir, { cwd: projectDir });
+    vi.spyOn(process, 'cwd').mockReturnValue(projectDir);
+
+    await expect(cmdPmMilestone(ctx, ['delete', '999'])).rejects.toThrow('Exit');
+    expect(ctx.ui.errors[0]).toContain('not found');
+  });
+
   it('routes "pm m add" to milestone add', async () => {
     const ctx = createMockContext(globalDir, { cwd: projectDir });
     vi.spyOn(process, 'cwd').mockReturnValue(projectDir);
@@ -356,6 +441,153 @@ describe('cmdPmMilestone', () => {
 
     expect(ctx.ui.logs.some((l) => l.includes('Shorthand Test'))).toBe(true);
   });
+
+  it('creates milestone with --description flag', async () => {
+    const ctx = createMockContext(globalDir, { cwd: projectDir });
+    vi.spyOn(process, 'cwd').mockReturnValue(projectDir);
+
+    await cmdPmMilestone(ctx, ['add', 'Phase 1', '--description', 'Initial development']);
+
+    // Verify doc file contains description
+    const docPath = path.join(globalDir, 'teams', teamId, 'milestones', '1.md');
+    const content = fs.readFileSync(docPath, 'utf-8');
+    expect(content).toContain('Phase 1');
+    expect(content).toContain('Initial development');
+  });
+
+  it('prints milestone doc by default', async () => {
+    const ctx = createMockContext(globalDir, { cwd: projectDir, json: true });
+    vi.spyOn(process, 'cwd').mockReturnValue(projectDir);
+
+    await cmdPmMilestone(ctx, ['add', 'Phase 1', '-d', 'Test description']);
+
+    (ctx.ui.json as ReturnType<typeof vi.fn>).mockClear();
+    await cmdPmMilestone(ctx, ['doc', '1']);
+
+    expect(ctx.ui.json).toHaveBeenCalledWith(
+      expect.objectContaining({
+        id: '1',
+        doc: expect.stringContaining('Phase 1'),
+      })
+    );
+  });
+
+  it('returns milestone doc in JSON format', async () => {
+    const ctx = createMockContext(globalDir, { cwd: projectDir, json: true });
+    vi.spyOn(process, 'cwd').mockReturnValue(projectDir);
+
+    await cmdPmMilestone(ctx, ['add', 'Phase 1']);
+    await cmdPmMilestone(ctx, ['doc', '1']);
+
+    const jsonOutput = ctx.ui.jsonData.find(
+      (d) => typeof d === 'object' && d !== null && 'doc' in d
+    ) as { id: string; doc: string };
+    expect(jsonOutput).toMatchObject({
+      id: '1',
+      doc: expect.stringContaining('Phase 1'),
+    });
+  });
+
+  it('exits with error for non-existent milestone doc', async () => {
+    const ctx = createMockContext(globalDir, { cwd: projectDir });
+    vi.spyOn(process, 'cwd').mockReturnValue(projectDir);
+
+    await expect(cmdPmMilestone(ctx, ['doc', '999'])).rejects.toThrow('Exit');
+    expect(ctx.ui.errors[0]).toContain('not found');
+  });
+
+  it('shows docPath with doc ref subcommand', async () => {
+    const ctx = createMockContext(globalDir, { cwd: projectDir, json: true });
+    vi.spyOn(process, 'cwd').mockReturnValue(projectDir);
+
+    await cmdPmMilestone(ctx, ['add', 'Phase 1']);
+
+    (ctx.ui.json as ReturnType<typeof vi.fn>).mockClear();
+    await cmdPmMilestone(ctx, ['doc', '1', 'ref']);
+
+    expect(ctx.ui.json).toHaveBeenCalledTimes(1);
+    expect(ctx.ui.json).toHaveBeenCalledWith(
+      expect.objectContaining({
+        id: '1',
+        docPath: expect.stringContaining('1.md'),
+      })
+    );
+  });
+
+  it('creates milestone with -d shorthand for description', async () => {
+    const ctx = createMockContext(globalDir, { cwd: projectDir });
+    vi.spyOn(process, 'cwd').mockReturnValue(projectDir);
+
+    await cmdPmMilestone(ctx, ['add', 'Sprint 1', '-d', 'Two week sprint']);
+
+    const docPath = path.join(globalDir, 'teams', teamId, 'milestones', '1.md');
+    const content = fs.readFileSync(docPath, 'utf-8');
+    expect(content).toContain('Sprint 1');
+    expect(content).toContain('Two week sprint');
+  });
+
+  it('prints full doc content including description', async () => {
+    const ctx = createMockContext(globalDir, { cwd: projectDir, json: true });
+    vi.spyOn(process, 'cwd').mockReturnValue(projectDir);
+
+    await cmdPmMilestone(ctx, ['add', 'Phase 1', '--description', 'Detailed description here']);
+
+    (ctx.ui.json as ReturnType<typeof vi.fn>).mockClear();
+    await cmdPmMilestone(ctx, ['doc', '1']);
+
+    expect(ctx.ui.json).toHaveBeenCalledTimes(1);
+    expect(ctx.ui.json).toHaveBeenCalledWith(
+      expect.objectContaining({
+        id: '1',
+        doc: expect.stringContaining('Detailed description here'),
+      })
+    );
+  });
+
+  it('sets milestone documentation with --body flag', async () => {
+    const ctx = createMockContext(globalDir, { cwd: projectDir });
+    vi.spyOn(process, 'cwd').mockReturnValue(projectDir);
+
+    await cmdPmMilestone(ctx, ['add', 'Sprint 1']);
+    await cmdPmMilestone(ctx, ['doc', '1', '--body', 'New milestone content']);
+    expect(ctx.ui.logs.some((l) => l.includes('Saved'))).toBe(true);
+
+    // Verify the content was saved
+    const jsonCtx = createMockContext(globalDir, { cwd: projectDir, json: true });
+    vi.spyOn(process, 'cwd').mockReturnValue(projectDir);
+    await cmdPmMilestone(jsonCtx, ['doc', '1']);
+
+    expect(jsonCtx.ui.json).toHaveBeenCalledWith(
+      expect.objectContaining({
+        doc: 'New milestone content',
+      })
+    );
+  });
+
+  it('sets milestone documentation with --body-file flag', async () => {
+    const ctx = createMockContext(globalDir, { cwd: projectDir });
+    vi.spyOn(process, 'cwd').mockReturnValue(projectDir);
+
+    await cmdPmMilestone(ctx, ['add', 'Sprint 1']);
+
+    // Create a temp file with content
+    const tempFile = path.join(projectDir, 'milestone-doc.md');
+    fs.writeFileSync(tempFile, '# Milestone content from file');
+
+    await cmdPmMilestone(ctx, ['doc', '1', '--body-file', tempFile]);
+    expect(ctx.ui.logs.some((l) => l.includes('Saved') && l.includes('from'))).toBe(true);
+
+    // Verify the content was saved
+    const jsonCtx = createMockContext(globalDir, { cwd: projectDir, json: true });
+    vi.spyOn(process, 'cwd').mockReturnValue(projectDir);
+    await cmdPmMilestone(jsonCtx, ['doc', '1']);
+
+    expect(jsonCtx.ui.json).toHaveBeenCalledWith(
+      expect.objectContaining({
+        doc: expect.stringContaining('Milestone content from file'),
+      })
+    );
+  });
 });
 
 // ─────────────────────────────────────────────────────────────
@@ -430,9 +662,35 @@ describe('cmdPmTask', () => {
 
     await cmdPmTask(ctx, ['add', 'Task 1']);
     await cmdPmTask(ctx, ['add', 'Task 2']);
+
+    (ctx.ui.table as ReturnType<typeof vi.fn>).mockClear();
     await cmdPmTask(ctx, ['list']);
 
-    expect(ctx.ui.table).toHaveBeenCalled();
+    expect(ctx.ui.table).toHaveBeenCalledTimes(1);
+    expect(ctx.ui.table).toHaveBeenCalledWith(
+      ['ID', 'TITLE', 'STATUS', 'MILESTONE'],
+      expect.arrayContaining([
+        expect.arrayContaining(['1', 'Task 1']),
+        expect.arrayContaining(['2', 'Task 2']),
+      ])
+    );
+  });
+
+  it('lists tasks when called without subcommand', async () => {
+    const ctx = createMockContext(globalDir, { cwd: projectDir });
+    vi.spyOn(process, 'cwd').mockReturnValue(projectDir);
+
+    await cmdPmTask(ctx, ['add', 'Task 1']);
+
+    // Clear mock call history after add, then verify empty args triggers list
+    (ctx.ui.table as ReturnType<typeof vi.fn>).mockClear();
+    await cmdPmTask(ctx, []);
+
+    expect(ctx.ui.table).toHaveBeenCalledTimes(1);
+    expect(ctx.ui.table).toHaveBeenCalledWith(
+      ['ID', 'TITLE', 'STATUS', 'MILESTONE'],
+      expect.arrayContaining([expect.arrayContaining(['1', 'Task 1'])])
+    );
   });
 
   it('filters task list by status', async () => {
@@ -464,6 +722,24 @@ describe('cmdPmTask', () => {
     expect(lastJson[0].milestone).toBe('1');
   });
 
+  it('hides tasks without milestone when hideOrphanTasks is enabled', async () => {
+    const ctx = createMockContext(globalDir, {
+      json: true,
+      cwd: projectDir,
+      defaults: { hideOrphanTasks: true },
+    });
+    vi.spyOn(process, 'cwd').mockReturnValue(projectDir);
+
+    await cmdPmMilestone(ctx, ['add', 'Phase 1']);
+    await cmdPmTask(ctx, ['add', 'With milestone', '--milestone', '1']);
+    await cmdPmTask(ctx, ['add', 'Without milestone']);
+    await cmdPmTask(ctx, ['list']);
+
+    const tasks = ctx.ui.jsonData[ctx.ui.jsonData.length - 1] as { title: string }[];
+    expect(tasks).toHaveLength(1);
+    expect(tasks[0].title).toBe('With milestone');
+  });
+
   it('displays task details', async () => {
     const ctx = createMockContext(globalDir, { json: true, cwd: projectDir });
     vi.spyOn(process, 'cwd').mockReturnValue(projectDir);
@@ -530,10 +806,10 @@ describe('cmdPmTask', () => {
 });
 
 // ─────────────────────────────────────────────────────────────
-// cmdPmDoc tests
+// cmdPmTask doc tests
 // ─────────────────────────────────────────────────────────────
 
-describe('cmdPmDoc', () => {
+describe('cmdPmTask doc', () => {
   let testDir: string;
   let globalDir: string;
   let projectDir: string;
@@ -560,23 +836,22 @@ describe('cmdPmDoc', () => {
     }
   });
 
-  it('prints task documentation with --print flag', async () => {
-    const ctx = createMockContext(globalDir, { cwd: projectDir });
+  it('prints task documentation by default', async () => {
+    const ctx = createMockContext(globalDir, { cwd: projectDir, json: true });
     vi.spyOn(process, 'cwd').mockReturnValue(projectDir);
 
-    // Capture console.log output
-    const logs: string[] = [];
-    const originalLog = console.log;
-    console.log = (msg: string) => logs.push(msg);
-
-    await cmdPmDoc(ctx, ['1', '--print']);
-
-    console.log = originalLog;
+    (ctx.ui.json as ReturnType<typeof vi.fn>).mockClear();
+    await cmdPmTask(ctx, ['doc', '1']);
 
-    expect(logs.some((l) => l.includes('Test Task'))).toBe(true);
+    expect(ctx.ui.json).toHaveBeenCalledWith(
+      expect.objectContaining({
+        id: '1',
+        doc: expect.stringContaining('Test Task'),
+      })
+    );
   });
 
-  it('opens documentation in $EDITOR', async () => {
+  it('opens documentation in $EDITOR with --edit flag', async () => {
     // This test is tricky because it spawns an editor
     // We'll just verify the command doesn't throw
     const ctx = createMockContext(globalDir, { cwd: projectDir });
@@ -587,7 +862,7 @@ describe('cmdPmDoc', () => {
     process.env.EDITOR = 'true'; // 'true' command exists and does nothing
 
     try {
-      await cmdPmDoc(ctx, ['1']);
+      await cmdPmTask(ctx, ['doc', '1', '--edit']);
       expect(ctx.ui.logs.some((l) => l.includes('Saved'))).toBe(true);
     } finally {
       if (originalEditor) {
@@ -602,9 +877,61 @@ describe('cmdPmDoc', () => {
     const ctx = createMockContext(globalDir, { cwd: projectDir });
     vi.spyOn(process, 'cwd').mockReturnValue(projectDir);
 
-    await expect(cmdPmDoc(ctx, ['999'])).rejects.toThrow('Exit');
+    await expect(cmdPmTask(ctx, ['doc', '999'])).rejects.toThrow('Exit');
     expect(ctx.ui.errors[0]).toContain('not found');
   });
+
+  it('sets documentation with --body flag', async () => {
+    const ctx = createMockContext(globalDir, { cwd: projectDir });
+    vi.spyOn(process, 'cwd').mockReturnValue(projectDir);
+
+    await cmdPmTask(ctx, ['doc', '1', '--body', 'New content via --body']);
+    expect(ctx.ui.logs.some((l) => l.includes('Saved'))).toBe(true);
+
+    // Verify the content was saved
+    const jsonCtx = createMockContext(globalDir, { cwd: projectDir, json: true });
+    vi.spyOn(process, 'cwd').mockReturnValue(projectDir);
+    await cmdPmTask(jsonCtx, ['doc', '1']);
+
+    expect(jsonCtx.ui.json).toHaveBeenCalledWith(
+      expect.objectContaining({
+        doc: 'New content via --body',
+      })
+    );
+  });
+
+  it('sets documentation with --body-file flag', async () => {
+    const ctx = createMockContext(globalDir, { cwd: projectDir });
+    vi.spyOn(process, 'cwd').mockReturnValue(projectDir);
+
+    // Create a temp file with content
+    const tempFile = path.join(projectDir, 'test-doc.md');
+    fs.writeFileSync(tempFile, '# Content from file\n\nThis came from a file.');
+
+    await cmdPmTask(ctx, ['doc', '1', '--body-file', tempFile]);
+    expect(ctx.ui.logs.some((l) => l.includes('Saved') && l.includes('from'))).toBe(true);
+
+    // Verify the content was saved
+    const jsonCtx = createMockContext(globalDir, { cwd: projectDir, json: true });
+    vi.spyOn(process, 'cwd').mockReturnValue(projectDir);
+    await cmdPmTask(jsonCtx, ['doc', '1']);
+
+    expect(jsonCtx.ui.json).toHaveBeenCalledWith(
+      expect.objectContaining({
+        doc: expect.stringContaining('Content from file'),
+      })
+    );
+  });
+
+  it('exits with error for non-existent --body-file', async () => {
+    const ctx = createMockContext(globalDir, { cwd: projectDir });
+    vi.spyOn(process, 'cwd').mockReturnValue(projectDir);
+
+    await expect(
+      cmdPmTask(ctx, ['doc', '1', '--body-file', '/nonexistent/file.md'])
+    ).rejects.toThrow('Exit');
+    expect(ctx.ui.errors[0]).toContain('File not found');
+  });
 });
 
 // ─────────────────────────────────────────────────────────────
@@ -638,23 +965,22 @@ describe('cmdPmLog', () => {
   });
 
   it('displays audit events', async () => {
-    const ctx = createMockContext(globalDir, { cwd: projectDir });
+    const ctx = createMockContext(globalDir, { cwd: projectDir, json: true });
     vi.spyOn(process, 'cwd').mockReturnValue(projectDir);
 
     // Create some events
     await cmdPmTask(ctx, ['add', 'Task 1']);
     await cmdPmTask(ctx, ['done', '1']);
 
-    const logs: string[] = [];
-    const originalLog = console.log;
-    console.log = (msg: string) => logs.push(String(msg));
-
+    (ctx.ui.json as ReturnType<typeof vi.fn>).mockClear();
     await cmdPmLog(ctx, []);
 
-    console.log = originalLog;
-
-    // Should show team_created and task events
-    expect(logs.some((l) => l.includes('team_created') || l.includes('task'))).toBe(true);
+    // cmdPmLog outputs array of events directly
+    expect(ctx.ui.json).toHaveBeenCalledWith(
+      expect.arrayContaining([
+        expect.objectContaining({ event: expect.stringMatching(/team_created|task/) }),
+      ])
+    );
   });
 
   it('limits number of events displayed', async () => {
@@ -746,7 +1072,14 @@ describe('cmdPmList', () => {
     const ctx = createMockContext(globalDir);
     await cmdPmList(ctx, []);
 
-    expect(ctx.ui.table).toHaveBeenCalled();
+    expect(ctx.ui.table).toHaveBeenCalledTimes(1);
+    expect(ctx.ui.table).toHaveBeenCalledWith(
+      ['', 'ID', 'NAME', 'BACKEND', 'CREATED'],
+      expect.arrayContaining([
+        expect.arrayContaining(['Project 1']),
+        expect.arrayContaining(['Project 2']),
+      ])
+    );
   });
 
   it('shows info message when no teams', async () => {
@@ -838,15 +1171,14 @@ describe('cmdPm router', () => {
   it('displays help for pm help', async () => {
     const ctx = createMockContext(globalDir, { cwd: projectDir });
 
-    const logs: string[] = [];
-    const originalLog = console.log;
-    console.log = (msg: string) => logs.push(String(msg));
-
-    await cmdPm(ctx, ['help']);
+    const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
 
-    console.log = originalLog;
-
-    expect(logs.some((l) => l.includes('tmux-team pm'))).toBe(true);
+    try {
+      await cmdPm(ctx, ['help']);
+      expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('tmux-team pm'));
+    } finally {
+      logSpy.mockRestore();
+    }
   });
 });
 
@@ -1096,19 +1428,21 @@ describe('Permission integration', () => {
 
     const ctx = createMockContext(globalDir, {
       cwd: projectDir,
+      json: true,
       agents: { codex: { deny: ['pm:doc:update'] } },
     });
     vi.spyOn(process, 'cwd').mockReturnValue(projectDir);
 
     // Read should work
-    const logs: string[] = [];
-    const originalLog = console.log;
-    console.log = (msg: string) => logs.push(msg);
-
-    await cmdPmDoc(ctx, ['1', '--print']);
-
-    console.log = originalLog;
-    expect(logs.some((l) => l.includes('Test task'))).toBe(true);
+    (ctx.ui.json as ReturnType<typeof vi.fn>).mockClear();
+    await cmdPmTask(ctx, ['doc', '1']);
+
+    expect(ctx.ui.json).toHaveBeenCalledWith(
+      expect.objectContaining({
+        id: '1',
+        doc: expect.stringContaining('Test task'),
+      })
+    );
   });
 
   it('uses TMUX_TEAM_ACTOR when TMT_AGENT_NAME is not set', async () => {