tmux-team 2.0.0-alpha.4 → 2.2.0

package/src/pm/commands.ts

@@ -24,6 +24,8 @@ import {
 import type { StorageAdapter } from './storage/adapter.js';
 import type { TaskStatus, MilestoneStatus, StorageBackend } from './types.js';
 import path from 'path';
+import fs from 'fs';
+import os from 'os';
 
 // ─────────────────────────────────────────────────────────────
 // Helpers
@@ -170,11 +172,17 @@ export async function cmdPmMilestone(ctx: Context, args: string[]): Promise<void
       return cmdMilestoneAdd(ctx, rest);
     case 'list':
     case 'ls':
+    case undefined:
       return cmdMilestoneList(ctx, rest);
     case 'done':
       return cmdMilestoneDone(ctx, rest);
+    case 'delete':
+    case 'rm':
+      return cmdMilestoneDelete(ctx, rest);
+    case 'doc':
+      return cmdMilestoneDoc(ctx, rest);
     default:
-      ctx.ui.error(`Unknown milestone command: ${subcommand}. Use: add, list, done`);
+      ctx.ui.error(`Unknown milestone command: ${subcommand}. Use: add, list, done, delete, doc`);
       ctx.exit(ExitCodes.ERROR);
   }
 }
@@ -185,13 +193,26 @@ async function cmdMilestoneAdd(ctx: Context, args: string[]): Promise<void> {
   const { ui, flags } = ctx;
   const { storage } = await requireTeam(ctx);
 
-  const name = args[0];
+  // Parse args: <name> [--description <text>]
+  let name = '';
+  let description: string | undefined;
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--description' || args[i] === '-d') {
+      description = args[++i];
+    } else if (args[i].startsWith('--description=')) {
+      description = args[i].slice(14);
+    } else if (!name) {
+      name = args[i];
+    }
+  }
+
   if (!name) {
-    ui.error('Usage: tmux-team pm milestone add <name>');
+    ui.error('Usage: tmux-team pm milestone add <name> [--description <text>]');
     ctx.exit(ExitCodes.ERROR);
   }
 
-  const milestone = await storage.createMilestone({ name });
+  const milestone = await storage.createMilestone({ name, description });
 
   await storage.appendEvent({
     event: 'milestone_created',
@@ -271,6 +292,167 @@ async function cmdMilestoneDone(ctx: Context, args: string[]): Promise<void> {
   }
 }
 
+async function cmdMilestoneDelete(ctx: Context, args: string[]): Promise<void> {
+  requirePermission(ctx, PermissionChecks.milestoneDelete());
+
+  const { ui, flags } = ctx;
+  const { storage } = await requireTeam(ctx);
+
+  const id = args[0];
+  if (!id) {
+    ui.error('Usage: tmux-team pm milestone delete <id>');
+    ctx.exit(ExitCodes.ERROR);
+  }
+
+  const milestone = await storage.getMilestone(id);
+  if (!milestone) {
+    ui.error(`Milestone ${id} not found`);
+    ctx.exit(ExitCodes.PANE_NOT_FOUND);
+  }
+
+  await storage.deleteMilestone(id);
+
+  await storage.appendEvent({
+    event: 'milestone_deleted',
+    id,
+    name: milestone.name,
+    actor: 'human',
+    ts: new Date().toISOString(),
+  });
+
+  if (flags.json) {
+    ui.json({ deleted: true, id, name: milestone.name });
+  } else {
+    ui.success(`Milestone #${id} "${milestone.name}" deleted`);
+  }
+}
+
+async function cmdMilestoneDoc(ctx: Context, args: string[]): Promise<void> {
+  const { ui, flags } = ctx;
+
+  // Parse arguments
+  let id: string | undefined;
+  let body: string | undefined;
+  let bodyFile: string | undefined;
+  let showRef = false;
+  let editMode = false;
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === 'ref') {
+      showRef = true;
+    } else if (arg === '--edit' || arg === '-e') {
+      editMode = true;
+    } else if (arg === '--body' || arg === '-b') {
+      body = args[++i];
+      if (body === undefined) {
+        ui.error('--body requires a value');
+        ctx.exit(ExitCodes.ERROR);
+      }
+    } else if (arg.startsWith('--body=')) {
+      body = arg.slice(7);
+    } else if (arg === '--body-file' || arg === '-f') {
+      bodyFile = args[++i];
+      if (bodyFile === undefined) {
+        ui.error('--body-file requires a value');
+        ctx.exit(ExitCodes.ERROR);
+      }
+    } else if (arg.startsWith('--body-file=')) {
+      bodyFile = arg.slice(12);
+    } else if (!id) {
+      id = arg;
+    }
+  }
+
+  if (!id) {
+    ui.error(
+      'Usage: tmux-team pm milestone doc <id> [ref | --edit | --body <text> | --body-file <path>]'
+    );
+    ctx.exit(ExitCodes.ERROR);
+  }
+
+  const isWriteMode = editMode || body !== undefined || bodyFile !== undefined;
+
+  // Check permission based on mode
+  if (isWriteMode) {
+    requirePermission(ctx, PermissionChecks.docUpdate());
+  } else {
+    requirePermission(ctx, PermissionChecks.docRead());
+  }
+
+  const { storage } = await requireTeam(ctx);
+  const milestone = await storage.getMilestone(id);
+  if (!milestone) {
+    ui.error(`Milestone ${id} not found`);
+    ctx.exit(ExitCodes.PANE_NOT_FOUND);
+  }
+
+  // Show reference (docPath)
+  if (showRef) {
+    if (flags.json) {
+      ui.json({ id, docPath: milestone.docPath });
+    } else {
+      console.log(milestone.docPath || '(no docPath)');
+    }
+    return;
+  }
+
+  // --body: set content directly
+  if (body !== undefined) {
+    await storage.setMilestoneDoc(id, body);
+    ui.success(`Saved documentation for milestone #${id}`);
+    return;
+  }
+
+  // --body-file: read content from file
+  if (bodyFile !== undefined) {
+    if (!fs.existsSync(bodyFile)) {
+      ui.error(`File not found: ${bodyFile}`);
+      ctx.exit(ExitCodes.ERROR);
+    }
+    const content = fs.readFileSync(bodyFile, 'utf-8');
+    await storage.setMilestoneDoc(id, content);
+    ui.success(`Saved documentation for milestone #${id} (from ${bodyFile})`);
+    return;
+  }
+
+  const doc = await storage.getMilestoneDoc(id);
+
+  // Default: print doc content
+  if (!editMode) {
+    if (flags.json) {
+      ui.json({ id, doc });
+    } else {
+      console.log(doc || '(empty)');
+    }
+    return;
+  }
+
+  // Edit mode: open in editor using temp file
+  const editor = process.env.EDITOR || 'vim';
+  const tempDir = os.tmpdir();
+  const tempFile = path.join(tempDir, `tmux-team-milestone-${id}.md`);
+
+  // Write current content to temp file
+  fs.writeFileSync(tempFile, doc || `# ${milestone.name}\n\n`);
+
+  const { spawnSync } = await import('child_process');
+  spawnSync(editor, [tempFile], { stdio: 'inherit' });
+
+  // Read edited content and sync back to storage
+  const newContent = fs.readFileSync(tempFile, 'utf-8');
+  await storage.setMilestoneDoc(id, newContent);
+
+  // Clean up temp file
+  try {
+    fs.unlinkSync(tempFile);
+  } catch {
+    // Ignore cleanup errors
+  }
+
+  ui.success(`Saved documentation for milestone #${id}`);
+}
+
 export async function cmdPmTask(ctx: Context, args: string[]): Promise<void> {
   const [subcommand, ...rest] = args;
 
@@ -279,6 +461,7 @@ export async function cmdPmTask(ctx: Context, args: string[]): Promise<void> {
       return cmdTaskAdd(ctx, rest);
     case 'list':
     case 'ls':
+    case undefined:
       return cmdTaskList(ctx, rest);
     case 'show':
       return cmdTaskShow(ctx, rest);
@@ -286,8 +469,10 @@ export async function cmdPmTask(ctx: Context, args: string[]): Promise<void> {
       return cmdTaskUpdate(ctx, rest);
     case 'done':
       return cmdTaskDone(ctx, rest);
+    case 'doc':
+      return cmdTaskDoc(ctx, rest);
     default:
-      ctx.ui.error(`Unknown task command: ${subcommand}. Use: add, list, show, update, done`);
+      ctx.ui.error(`Unknown task command: ${subcommand}. Use: add, list, show, update, done, doc`);
       ctx.exit(ExitCodes.ERROR);
   }
 }
@@ -348,12 +533,13 @@ async function cmdTaskAdd(ctx: Context, args: string[]): Promise<void> {
 async function cmdTaskList(ctx: Context, args: string[]): Promise<void> {
   requirePermission(ctx, PermissionChecks.taskList());
 
-  const { ui, flags } = ctx;
+  const { ui, flags, config } = ctx;
   const { storage } = await requireTeam(ctx);
 
   // Parse filters
   let milestone: string | undefined;
   let status: TaskStatus | undefined;
+  let showAll = false;
 
   for (let i = 0; i < args.length; i++) {
     if (args[i] === '--milestone' || args[i] === '-m') {
@@ -364,10 +550,20 @@ async function cmdTaskList(ctx: Context, args: string[]): Promise<void> {
       status = parseStatus(args[++i]);
     } else if (args[i].startsWith('--status=')) {
       status = parseStatus(args[i].slice(9));
+    } else if (args[i] === '--all' || args[i] === '-a') {
+      showAll = true;
     }
   }
 
-  const tasks = await storage.listTasks({ milestone, status });
+  const hideOrphanTasks = config.defaults.hideOrphanTasks;
+
+  // By default, exclude tasks in completed milestones (unless --all)
+  const tasks = await storage.listTasks({
+    milestone,
+    status,
+    excludeCompletedMilestones: !showAll,
+    hideOrphanTasks,
+  });
 
   if (flags.json) {
     ui.json(tasks);
@@ -385,6 +581,16 @@ async function cmdTaskList(ctx: Context, args: string[]): Promise<void> {
     tasks.map((t) => [t.id, t.title.slice(0, 40), formatStatus(t.status), t.milestone || '-'])
   );
   console.log();
+
+  if (!flags.json) {
+    const modeHint = hideOrphanTasks
+      ? 'hiding tasks without milestones'
+      : 'showing tasks without milestones';
+    const toggleHint = hideOrphanTasks ? 'false' : 'true';
+    ui.info(
+      `List mode: ${modeHint}. Use: ${colors.cyan(`tmt config set hideOrphanTasks ${toggleHint}`)}`
+    );
+  }
 }
 
 async function cmdTaskShow(ctx: Context, args: string[]): Promise<void> {
@@ -527,34 +733,99 @@ async function cmdTaskDone(ctx: Context, args: string[]): Promise<void> {
   }
 }
 
-export async function cmdPmDoc(ctx: Context, args: string[]): Promise<void> {
+async function cmdTaskDoc(ctx: Context, args: string[]): Promise<void> {
   const { ui, flags } = ctx;
 
-  const id = args[0];
+  // Parse arguments
+  let id: string | undefined;
+  let body: string | undefined;
+  let bodyFile: string | undefined;
+  let showRef = false;
+  let editMode = false;
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === 'ref') {
+      showRef = true;
+    } else if (arg === '--edit' || arg === '-e') {
+      editMode = true;
+    } else if (arg === '--body' || arg === '-b') {
+      body = args[++i];
+      if (body === undefined) {
+        ui.error('--body requires a value');
+        ctx.exit(ExitCodes.ERROR);
+      }
+    } else if (arg.startsWith('--body=')) {
+      body = arg.slice(7);
+    } else if (arg === '--body-file' || arg === '-f') {
+      bodyFile = args[++i];
+      if (bodyFile === undefined) {
+        ui.error('--body-file requires a value');
+        ctx.exit(ExitCodes.ERROR);
+      }
+    } else if (arg.startsWith('--body-file=')) {
+      bodyFile = arg.slice(12);
+    } else if (!id) {
+      id = arg;
+    }
+  }
+
   if (!id) {
-    ui.error('Usage: tmux-team pm doc <id> [--print]');
+    ui.error(
+      'Usage: tmux-team pm task doc <id> [ref | --edit | --body <text> | --body-file <path>]'
+    );
     ctx.exit(ExitCodes.ERROR);
   }
 
-  const printOnly = args.includes('--print') || args.includes('-p');
+  const isWriteMode = editMode || body !== undefined || bodyFile !== undefined;
 
   // Check permission based on mode
-  if (printOnly || flags.json) {
-    requirePermission(ctx, PermissionChecks.docRead());
-  } else {
+  if (isWriteMode) {
     requirePermission(ctx, PermissionChecks.docUpdate());
+  } else {
+    requirePermission(ctx, PermissionChecks.docRead());
   }
 
-  const { teamId, storage } = await requireTeam(ctx);
+  const { storage } = await requireTeam(ctx);
   const task = await storage.getTask(id);
   if (!task) {
     ui.error(`Task ${id} not found`);
     ctx.exit(ExitCodes.PANE_NOT_FOUND);
   }
 
+  // Show reference (docPath)
+  if (showRef) {
+    if (flags.json) {
+      ui.json({ id, docPath: task.docPath });
+    } else {
+      console.log(task.docPath || '(no docPath)');
+    }
+    return;
+  }
+
+  // --body: set content directly
+  if (body !== undefined) {
+    await storage.setTaskDoc(id, body);
+    ui.success(`Saved documentation for task #${id}`);
+    return;
+  }
+
+  // --body-file: read content from file
+  if (bodyFile !== undefined) {
+    if (!fs.existsSync(bodyFile)) {
+      ui.error(`File not found: ${bodyFile}`);
+      ctx.exit(ExitCodes.ERROR);
+    }
+    const content = fs.readFileSync(bodyFile, 'utf-8');
+    await storage.setTaskDoc(id, content);
+    ui.success(`Saved documentation for task #${id} (from ${bodyFile})`);
+    return;
+  }
+
   const doc = await storage.getTaskDoc(id);
 
-  if (printOnly || flags.json) {
+  // Default: print doc content
+  if (!editMode) {
     if (flags.json) {
       ui.json({ id, doc });
     } else {
@@ -563,12 +834,27 @@ export async function cmdPmDoc(ctx: Context, args: string[]): Promise<void> {
     return;
   }
 
-  // Open in editor
+  // Edit mode: open in editor using temp file
   const editor = process.env.EDITOR || 'vim';
-  const docPath = path.join(getTeamsDir(ctx.paths.globalDir), teamId, 'tasks', `${id}.md`);
+  const tempDir = os.tmpdir();
+  const tempFile = path.join(tempDir, `tmux-team-task-${id}.md`);
+
+  // Write current content to temp file
+  fs.writeFileSync(tempFile, doc || `# ${task.title}\n\n`);
 
   const { spawnSync } = await import('child_process');
-  spawnSync(editor, [docPath], { stdio: 'inherit' });
+  spawnSync(editor, [tempFile], { stdio: 'inherit' });
+
+  // Read edited content and sync back to storage
+  const newContent = fs.readFileSync(tempFile, 'utf-8');
+  await storage.setTaskDoc(id, newContent);
+
+  // Clean up temp file
+  try {
+    fs.unlinkSync(tempFile);
+  } catch {
+    // Ignore cleanup errors
+  }
 
   ui.success(`Saved documentation for task #${id}`);
 }
@@ -661,8 +947,6 @@ export async function cmdPm(ctx: Context, args: string[]): Promise<void> {
       return cmdPmMilestone(ctx, rest);
     case 'task':
       return cmdPmTask(ctx, rest);
-    case 'doc':
-      return cmdPmDoc(ctx, rest);
     case 'log':
       return cmdPmLog(ctx, rest);
     case 'list':
@@ -687,15 +971,19 @@ ${colors.yellow('COMMANDS')}
     --backend <fs|github>            Storage backend (default: fs)
     --repo <owner/repo>              GitHub repo (required for github backend)
   ${colors.green('list')}                              List all teams
-  ${colors.green('milestone')} add <name>              Add milestone (shorthand: m)
+  ${colors.green('milestone')} add <name> [-d <desc>]   Add milestone (shorthand: m)
   ${colors.green('milestone')} list                    List milestones
   ${colors.green('milestone')} done <id>               Mark milestone complete
+  ${colors.green('milestone')} delete <id>             Delete milestone (rm)
+  ${colors.green('milestone')} doc <id> [options]       Print/update doc
+                                     ref: show path, --edit: edit, --body: set text, --body-file: set from file
   ${colors.green('task')} add <title> [--milestone]    Add task (shorthand: t)
-  ${colors.green('task')} list [--status] [--milestone] List tasks
+  ${colors.green('task')} list [options]               List tasks (hides done milestones by default)
+                                     --all: include tasks in completed milestones
   ${colors.green('task')} show <id>                    Show task details
   ${colors.green('task')} update <id> --status <s>     Update task status
   ${colors.green('task')} done <id>                    Mark task complete
-  ${colors.green('doc')} <id> [--print]                View/edit task documentation
+  ${colors.green('task')} doc <id> [options]            Print/update doc (same options as milestone doc)
   ${colors.green('log')} [--limit <n>]                 Show audit event log
 
 ${colors.yellow('BACKENDS')}

package/src/pm/permissions.test.ts

@@ -16,7 +16,13 @@ function createMockConfig(agents: Record<string, { deny?: string[] }>): Resolved
   return {
     mode: 'polling',
     preambleMode: 'always',
-    defaults: { timeout: 60, pollInterval: 1, captureLines: 100 },
+    defaults: {
+      timeout: 60,
+      pollInterval: 1,
+      captureLines: 100,
+      preambleEvery: 3,
+      hideOrphanTasks: false,
+    },
     agents,
     paneRegistry: {},
   };
@@ -330,3 +336,109 @@ describe('resolveActor', () => {
     expect(result.source).toBe('env');
   });
 });
+
+describe('checkPermission with local config (integration)', () => {
+  const originalEnv = { ...process.env };
+
+  beforeEach(() => {
+    process.env = { ...originalEnv };
+    delete process.env.TMUX;
+  });
+
+  afterEach(() => {
+    process.env = { ...originalEnv };
+  });
+
+  // Helper to create config as if loaded from local tmux-team.json
+  function createConfigWithLocalPermissions(
+    localAgents: Record<string, { preamble?: string; deny?: string[] }>
+  ): ResolvedConfig {
+    return {
+      mode: 'polling',
+      preambleMode: 'always',
+      defaults: {
+        timeout: 60,
+        pollInterval: 1,
+        captureLines: 100,
+        preambleEvery: 3,
+        hideOrphanTasks: false,
+      },
+      agents: localAgents, // This simulates merged local config
+      paneRegistry: {},
+    };
+  }
+
+  it('enforces local deny rules for specific agent', () => {
+    process.env.TMT_AGENT_NAME = 'claude';
+
+    // Simulates local config with: claude has deny rules, codex does not
+    const config = createConfigWithLocalPermissions({
+      claude: { deny: ['pm:task:update(status)', 'pm:milestone:update(status)'] },
+      codex: { preamble: 'Code quality guard' }, // No deny
+    });
+
+    // Claude is blocked from status updates
+    expect(checkPermission(config, PermissionChecks.taskUpdate(['status'])).allowed).toBe(false);
+    expect(checkPermission(config, PermissionChecks.milestoneUpdate(['status'])).allowed).toBe(
+      false
+    );
+
+    // Claude can still do other things
+    expect(checkPermission(config, PermissionChecks.taskCreate()).allowed).toBe(true);
+    expect(checkPermission(config, PermissionChecks.taskList()).allowed).toBe(true);
+    expect(checkPermission(config, PermissionChecks.taskUpdate(['assignee'])).allowed).toBe(true);
+  });
+
+  it('allows agent without deny rules to do everything', () => {
+    process.env.TMT_AGENT_NAME = 'codex';
+
+    const config = createConfigWithLocalPermissions({
+      claude: { deny: ['pm:task:update(status)'] },
+      codex: { preamble: 'Code quality guard' }, // No deny
+    });
+
+    // Codex can do everything including status updates
+    expect(checkPermission(config, PermissionChecks.taskUpdate(['status'])).allowed).toBe(true);
+    expect(checkPermission(config, PermissionChecks.milestoneUpdate(['status'])).allowed).toBe(
+      true
+    );
+    expect(checkPermission(config, PermissionChecks.taskCreate()).allowed).toBe(true);
+    expect(checkPermission(config, PermissionChecks.taskDelete()).allowed).toBe(true);
+  });
+
+  it('project-specific permissions: implementer vs reviewer roles', () => {
+    // Real-world scenario: claude implements, codex reviews
+    const config = createConfigWithLocalPermissions({
+      claude: {
+        preamble: 'You implement features. Ask Codex for review before marking done.',
+        deny: ['pm:task:update(status)', 'pm:milestone:update(status)'],
+      },
+      codex: {
+        preamble: 'You are the code quality guard. Mark tasks done after reviewing.',
+        // No deny - codex can update status
+      },
+    });
+
+    // Claude cannot mark tasks done
+    process.env.TMT_AGENT_NAME = 'claude';
+    expect(checkPermission(config, PermissionChecks.taskUpdate(['status'])).allowed).toBe(false);
+
+    // Codex can mark tasks done
+    process.env.TMT_AGENT_NAME = 'codex';
+    expect(checkPermission(config, PermissionChecks.taskUpdate(['status'])).allowed).toBe(true);
+  });
+
+  it('returns correct result when permission denied', () => {
+    process.env.TMT_AGENT_NAME = 'claude';
+
+    const config = createConfigWithLocalPermissions({
+      claude: { deny: ['pm:task:update(status)'] },
+    });
+
+    const result = checkPermission(config, PermissionChecks.taskUpdate(['status']));
+
+    expect(result.allowed).toBe(false);
+    expect(result.actor).toBe('claude');
+    expect(result.source).toBe('env');
+  });
+});

package/src/pm/permissions.ts

@@ -105,11 +105,24 @@ function getCurrentPane(): string | null {
     return null;
   }
 
+  // TMUX_PANE contains the pane ID (e.g., %130) for the shell that's running.
+  // We must use -t "$TMUX_PANE" to get the correct pane, otherwise tmux returns
+  // the currently focused pane which may be different when commands are sent
+  // via send-keys from another pane.
+  // See: https://github.com/tmux/tmux/issues/4638
+  const tmuxPane = process.env.TMUX_PANE;
+  if (!tmuxPane) {
+    return null;
+  }
+
   try {
-    const result = execSync("tmux display-message -p '#{window_index}.#{pane_index}'", {
-      encoding: 'utf-8',
-      timeout: 1000,
-    }).trim();
+    const result = execSync(
+      `tmux display-message -p -t "${tmuxPane}" '#{window_index}.#{pane_index}'`,
+      {
+        encoding: 'utf-8',
+        timeout: 1000,
+      }
+    ).trim();
     return result || null;
   } catch {
     return null;
@@ -265,6 +278,7 @@ export const PermissionChecks = {
     action: 'update',
     fields,
   }),
+  milestoneDelete: (): PermissionCheck => ({ resource: 'milestone', action: 'delete', fields: [] }),
 
   // Doc operations
   docRead: (): PermissionCheck => ({ resource: 'doc', action: 'read', fields: [] }),

package/src/pm/storage/adapter.ts

@@ -43,6 +43,8 @@ export interface StorageAdapter {
   // Documentation
   getTaskDoc(id: string): Promise<string | null>;
   setTaskDoc(id: string, content: string): Promise<void>;
+  getMilestoneDoc(id: string): Promise<string | null>;
+  setMilestoneDoc(id: string, content: string): Promise<void>;
 
   // Audit log
   appendEvent(event: AuditEvent): Promise<void>;