import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
import os from 'node:os';
import path from 'node:path';
import { spawn, type ChildProcessWithoutNullStreams } from 'node:child_process';
import { fileURLToPath } from 'node:url';

function parseJsonToolResult(result: unknown) {
  const response = result as {
    content?: Array<{ text?: string }>;
    isError?: boolean;
  };
  const text = response.content?.[0]?.text;
  if (response.isError) {
    throw new Error(text ?? 'Tool returned an unspecified error');
  }
  return JSON.parse(text ?? 'null');
}

async function writeTeamConfig(claudeDir: string, teamName: string) {
  const teamDir = path.join(claudeDir, 'teams', teamName);
  await mkdir(teamDir, { recursive: true });
  await writeFile(
    path.join(teamDir, 'config.json'),
    JSON.stringify(
      {
        name: teamName,
        members: [
          { name: 'team-lead', agentType: 'team-lead' },
          { name: 'alice', agentType: 'teammate', role: 'developer' },
          { name: 'bob', agentType: 'teammate', role: 'reviewer' },
        ],
      },
      null,
      2
    ),
    'utf8'
  );
}

async function writeBulkTaskRows(claudeDir: string, teamName: string, count: number) {
  const tasksDir = path.join(claudeDir, 'tasks', teamName);
  await mkdir(tasksDir, { recursive: true });

  await Promise.all(
    Array.from({ length: count }, async (_, index) => {
      const ordinal = String(index + 1).padStart(3, '0');
      const id = `bulk-${ordinal}`;
      const timestamp = new Date(Date.UTC(2026, 0, 1, 0, 0, index)).toISOString();
      await writeFile(
        path.join(tasksDir, `${id}.json`),
        JSON.stringify(
          {
            id,
            displayId: id,
            subject: `Bulk inventory task ${ordinal}`,
            description: `Large description that must not be returned in task_list row ${ordinal}`,
            owner: index % 2 === 0 ? 'alice' : 'bob',
            status: index % 3 === 0 ? 'completed' : 'pending',
            reviewState: 'none',
            commentCount: 99,
            comments: [
              {
                id: `comment-${ordinal}`,
                author: 'alice',
                text: 'Large comment that must not be returned in task_list rows',
              },
            ],
            historyEvents: [{ type: 'task_created', status: 'pending', timestamp }],
            workIntervals: [{ startedAt: timestamp }],
            createdAt: timestamp,
            updatedAt: timestamp,
          },
          null,
          2
        ),
        'utf8'
      );
    })
  );
}

async function writeInventoryTaskRow(
  claudeDir: string,
  teamName: string,
  task: {
    id: string;
    owner: string;
    subject: string;
    status?: 'pending' | 'in_progress' | 'completed' | 'deleted';
    createdAt: string;
  }
) {
  const tasksDir = path.join(claudeDir, 'tasks', teamName);
  await mkdir(tasksDir, { recursive: true });
  await writeFile(
    path.join(tasksDir, `${task.id}.json`),
    JSON.stringify(
      {
        id: task.id,
        displayId: task.id,
        subject: task.subject,
        description: `Drill-down description for ${task.subject}`,
        owner: task.owner,
        status: task.status ?? 'pending',
        reviewState: 'none',
        comments: [],
        historyEvents: [{ type: 'task_created', status: task.status ?? 'pending', timestamp: task.createdAt }],
        createdAt: task.createdAt,
        updatedAt: task.createdAt,
      },
      null,
      2
    ),
    'utf8'
  );
}

class McpStdIoClient {
  private readonly child: ChildProcessWithoutNullStreams;
  private stdoutBuffer = '';

  constructor(serverPath: string, cwd: string) {
    this.child = spawn('node', [serverPath], {
      cwd,
      stdio: ['pipe', 'pipe', 'pipe'],
    });

    this.child.stdout.setEncoding('utf8');
    this.child.stdout.on('data', (chunk: string) => {
      this.stdoutBuffer += chunk;
    });
  }

  async initialize() {
    const response = await this.request(1, 'initialize', {
      protocolVersion: '2024-11-05',
      capabilities: {},
      clientInfo: { name: 'vitest-e2e', version: '1.0.0' },
    });

    this.notify('notifications/initialized');
    return response;
  }

  async listTools() {
    return this.request(2, 'tools/list', {});
  }

  async callTool(name: string, args: Record<string, unknown>, id = 3) {
    return this.request(id, 'tools/call', { name, arguments: args });
  }

  async close() {
    this.child.kill('SIGTERM');
    await new Promise<void>((resolve) => {
      this.child.once('exit', () => resolve());
      setTimeout(() => resolve(), 1000).unref();
    });
  }

  private notify(method: string, params?: Record<string, unknown>) {
    this.child.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', method, ...(params ? { params } : {}) })}\n`);
  }

  private async request(id: number, method: string, params: Record<string, unknown>) {
    this.child.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', id, method, params })}\n`);
    return this.readMessage(id);
  }

  private async readMessage(expectedId: number) {
    const deadline = Date.now() + 15000;

    while (Date.now() < deadline) {
      const newlineIndex = this.stdoutBuffer.indexOf('\n');
      if (newlineIndex !== -1) {
        const line = this.stdoutBuffer.slice(0, newlineIndex).trim();
        this.stdoutBuffer = this.stdoutBuffer.slice(newlineIndex + 1);

        if (!line) {
          continue;
        }

        const parsed = JSON.parse(line) as { id?: number };
        if (parsed.id === expectedId) {
          return parsed;
        }
      }

      await new Promise((resolve) => setTimeout(resolve, 20));
    }

    throw new Error(`Timed out waiting for MCP response ${expectedId}`);
  }
}

describe('agent-teams-mcp stdio e2e', () => {
  const serverPath = fileURLToPath(new URL('../dist/index.js', import.meta.url));
  const workspaceRoot = fileURLToPath(new URL('../..', import.meta.url));

  let claudeDir: string;

  beforeEach(async () => {
    claudeDir = await mkdtemp(path.join(os.tmpdir(), 'agent-teams-mcp-e2e-'));
  });

  afterEach(async () => {
    await rm(claudeDir, { recursive: true, force: true });
  });

  it('boots over stdio, lists task tools, and executes task lifecycle calls', async () => {
    await writeTeamConfig(claudeDir, 'e2e-team');
    const client = new McpStdIoClient(serverPath, workspaceRoot);

    try {
      const init = await client.initialize();
      expect(init).toHaveProperty('result');

      const tools = (await client.listTools()) as {
        result?: { tools?: Array<{ name: string; description?: string }> };
      };
      const registeredTools = tools.result?.tools ?? [];
      const toolNames = registeredTools.map((tool) => tool.name);
      const taskListTool = registeredTools.find((tool) => tool.name === 'task_list');

      expect(toolNames).toContain('task_create');
      expect(toolNames).toContain('task_start');
      expect(toolNames).toContain('task_briefing');
      expect(toolNames).toContain('member_briefing');
      expect(toolNames).toContain('review_approve');
      expect(toolNames).toContain('lead_briefing');
      expect(taskListTool?.description).toContain(
        'Use it to browse, filter, and drill into inventory, not as a primary working queue.'
      );
      expect(taskListTool?.description).toContain('Deleted tasks are excluded.');

      const createResult = await client.callTool(
        'task_create',
        {
          claudeDir,
          teamName: 'e2e-team',
          subject: 'Smoke task',
          owner: 'alice',
          description: 'Smoke task description',
        },
        3
      );
      const createdTask = parseJsonToolResult((createResult as { result: unknown }).result);

      expect(createdTask.subject).toBe('Smoke task');
      expect(createdTask.owner).toBe('alice');
      expect(typeof createdTask.id).toBe('string');

      const startResult = await client.callTool(
        'task_start',
        {
          claudeDir,
          teamName: 'e2e-team',
          taskId: createdTask.id,
          actor: 'alice',
        },
        4
      );
      const startedTask = parseJsonToolResult((startResult as { result: unknown }).result);

      expect(startedTask.status).toBe('in_progress');
      expect(startedTask.id).toBe(createdTask.id);

      const commentResult = await client.callTool(
        'task_add_comment',
        {
          claudeDir,
          teamName: 'e2e-team',
          taskId: createdTask.id,
          text: 'Working through the smoke task.',
          from: 'alice',
        },
        5
      );
      const commentPayload = parseJsonToolResult((commentResult as { result: unknown }).result);
      expect(commentPayload.task.id).toBe(createdTask.id);
      expect(commentPayload.comment.text).toBe('Working through the smoke task.');

      const reviewCreateResult = await client.callTool(
        'task_create',
        {
          claudeDir,
          teamName: 'e2e-team',
          subject: 'Review task',
          owner: 'alice',
        },
        6
      );
      const reviewTask = parseJsonToolResult((reviewCreateResult as { result: unknown }).result);

      const completeResult = await client.callTool(
        'task_complete',
        {
          claudeDir,
          teamName: 'e2e-team',
          taskId: reviewTask.id,
          actor: 'alice',
        },
        7
      );
      const completedTask = parseJsonToolResult((completeResult as { result: unknown }).result);
      expect(completedTask.status).toBe('completed');

      const reviewRequestResult = await client.callTool(
        'review_request',
        {
          claudeDir,
          teamName: 'e2e-team',
          taskId: reviewTask.id,
          from: 'team-lead',
          reviewer: 'bob',
        },
        8
      );
      const reviewRequestedTask = parseJsonToolResult(
        (reviewRequestResult as { result: unknown }).result
      );
      expect(reviewRequestedTask.reviewState).toBe('review');

      const unassignedCreateResult = await client.callTool(
        'task_create',
        {
          claudeDir,
          teamName: 'e2e-team',
          subject: 'Needs owner assignment',
        },
        9
      );
      const unassignedTask = parseJsonToolResult(
        (unassignedCreateResult as { result: unknown }).result
      );
      expect(unassignedTask.owner).toBeUndefined();

      const taskBriefingResult = await client.callTool(
        'task_briefing',
        {
          claudeDir,
          teamName: 'e2e-team',
          memberName: 'alice',
        },
        10
      );
      const taskBriefingText = (
        ((taskBriefingResult as { result: { content?: Array<{ text?: string }> } }).result
          ?.content?.[0]?.text as string | undefined) ?? ''
      );
      expect(taskBriefingText).toContain('Task briefing for alice:');
      expect(taskBriefingText).toContain(
        'Primary queue for alice. Act only on Actionable items. Awareness items are watch-only context unless the lead reroutes the task or you become the actionOwner.'
      );
      expect(taskBriefingText).toContain(
        'Use task_list only to search/browse inventory rows, not as your working queue.'
      );
      expect(taskBriefingText).toContain('Actionable:');
      expect(taskBriefingText).toContain(`#${createdTask.displayId}`);
      expect(taskBriefingText).toContain('reason=owner_executing');
      expect(taskBriefingText).toContain('Description: Smoke task description');
      expect(taskBriefingText).toContain('Working through the smoke task.');
      expect(taskBriefingText).toContain('Awareness:');
      expect(taskBriefingText).toContain(`#${reviewTask.displayId}`);

      const memberBriefingResult = await client.callTool(
        'member_briefing',
        {
          claudeDir,
          teamName: 'e2e-team',
          memberName: 'alice',
        },
        11
      );
      const memberBriefingText = (
        ((memberBriefingResult as { result: { content?: Array<{ text?: string }> } }).result
          ?.content?.[0]?.text as string | undefined) ?? ''
      );
      expect(memberBriefingText).toContain(
        'Use task_briefing as your primary working queue whenever you need to see assigned work.'
      );
      expect(memberBriefingText).toContain(
        'Use task_list only to search/browse inventory rows, not as your working queue.'
      );
      expect(memberBriefingText).toContain(
        'Awareness items are watch-only context and do not authorize you to start work unless the lead reroutes the task or you become the actionOwner.'
      );

      const reviewerTaskBriefingResult = await client.callTool(
        'task_briefing',
        {
          claudeDir,
          teamName: 'e2e-team',
          memberName: 'bob',
        },
        12
      );
      const reviewerTaskBriefingText = (
        ((reviewerTaskBriefingResult as { result: { content?: Array<{ text?: string }> } }).result
          ?.content?.[0]?.text as string | undefined) ?? ''
      );
      expect(reviewerTaskBriefingText).toContain('Task briefing for bob:');
      expect(reviewerTaskBriefingText).toContain('Actionable:');
      expect(reviewerTaskBriefingText).toContain(`#${reviewTask.displayId}`);
      expect(reviewerTaskBriefingText).toContain('reviewer=bob');
      expect(reviewerTaskBriefingText).toContain('reason=review_requested_waiting_pickup');

      const leadBriefingResult = await client.callTool(
        'lead_briefing',
        {
          claudeDir,
          teamName: 'e2e-team',
        },
        13
      );
      const leadBriefingText = (
        ((leadBriefingResult as { result: { content?: Array<{ text?: string }> } }).result
          ?.content?.[0]?.text as string | undefined) ?? ''
      );
      expect(leadBriefingText).toContain('Lead queue for team-lead on team "e2e-team":');
      expect(leadBriefingText).toContain(
        'Primary lead queue. Sections below already represent lead-owned actions or watch-only context.'
      );
      expect(leadBriefingText).toContain(
        'Use task_list only for search, filtering, and drill-down inventory lookups.'
      );
      expect(leadBriefingText).toContain('Needs owner assignment:');
      expect(leadBriefingText).toContain(`#${unassignedTask.displayId}`);
      expect(leadBriefingText).toContain('reason=owner_missing');
      expect(leadBriefingText).toContain('Watching:');
      expect(leadBriefingText).toContain(`#${reviewTask.displayId}`);

      const inventoryResult = await client.callTool(
        'task_list',
        {
          claudeDir,
          teamName: 'e2e-team',
        },
        14
      );
      const inventoryRows = parseJsonToolResult((inventoryResult as { result: unknown }).result);
      const reviewInventoryRow = inventoryRows.find(
        (row: { id: string }) => row.id === reviewTask.id
      ) as Record<string, unknown> | undefined;
      const unassignedInventoryRow = inventoryRows.find(
        (row: { id: string }) => row.id === unassignedTask.id
      ) as Record<string, unknown> | undefined;
      expect(reviewInventoryRow).toMatchObject({
        id: reviewTask.id,
        subject: 'Review task',
        owner: 'alice',
        status: 'completed',
        reviewState: 'review',
      });
      expect(reviewInventoryRow?.description).toBeUndefined();
      expect(reviewInventoryRow?.comments).toBeUndefined();
      expect(reviewInventoryRow?.historyEvents).toBeUndefined();
      expect(reviewInventoryRow?.workIntervals).toBeUndefined();
      expect(unassignedInventoryRow).toMatchObject({
        id: unassignedTask.id,
        subject: 'Needs owner assignment',
        status: 'pending',
        reviewState: 'none',
      });
      expect(unassignedInventoryRow?.owner).toBeUndefined();

      const filteredListResult = await client.callTool(
        'task_list',
        {
          claudeDir,
          teamName: 'e2e-team',
          reviewState: 'review',
          kanbanColumn: 'review',
        },
        15
      );
      const filteredTasks = parseJsonToolResult((filteredListResult as { result: unknown }).result);
      expect(filteredTasks).toHaveLength(1);
      expect(filteredTasks[0]).toMatchObject({
        id: reviewTask.id,
        status: 'completed',
        reviewState: 'review',
        owner: 'alice',
      });
    } finally {
      await client.close();
    }
  });

  it('fails closed for primary queue and inventory tools when team config is missing over stdio', async () => {
    const client = new McpStdIoClient(serverPath, workspaceRoot);
    const expected =
      'Unknown team "team-lead". Board tools require an existing configured team with config.json.';

    try {
      await client.initialize();

      const leadBriefing = (await client.callTool(
        'lead_briefing',
        {
          claudeDir,
          teamName: 'team-lead',
        },
        40
      )) as { result?: { isError?: boolean; content?: Array<{ text?: string }> } };
      expect(leadBriefing.result?.isError).toBe(true);
      expect(leadBriefing.result?.content?.[0]?.text).toContain(expected);

      const taskBriefing = (await client.callTool(
        'task_briefing',
        {
          claudeDir,
          teamName: 'team-lead',
          memberName: 'alice',
        },
        41
      )) as { result?: { isError?: boolean; content?: Array<{ text?: string }> } };
      expect(taskBriefing.result?.isError).toBe(true);
      expect(taskBriefing.result?.content?.[0]?.text).toContain(expected);

      const taskList = (await client.callTool(
        'task_list',
        {
          claudeDir,
          teamName: 'team-lead',
        },
        42
      )) as { result?: { isError?: boolean; content?: Array<{ text?: string }> } };
      expect(taskList.result?.isError).toBe(true);
      expect(taskList.result?.content?.[0]?.text).toContain(expected);
    } finally {
      await client.close();
    }
  });

  it('caps high-volume task_list inventory over stdio and keeps rows compact', async () => {
    await writeTeamConfig(claudeDir, 'bulk-inventory-team');
    await writeBulkTaskRows(claudeDir, 'bulk-inventory-team', 225);
    const client = new McpStdIoClient(serverPath, workspaceRoot);

    try {
      await client.initialize();

      const tools = (await client.listTools()) as {
        result?: { tools?: Array<{ name: string; description?: string }> };
      };
      const taskListTool = tools.result?.tools?.find((tool) => tool.name === 'task_list');
      expect(taskListTool?.description).toContain('Defaults to 50 rows and caps at 200 rows');

      const defaultInventoryResult = await client.callTool(
        'task_list',
        {
          claudeDir,
          teamName: 'bulk-inventory-team',
        },
        21
      );
      const defaultRows = parseJsonToolResult(
        (defaultInventoryResult as { result: unknown }).result
      ) as Array<Record<string, unknown>>;
      expect(defaultRows).toHaveLength(50);
      for (const row of defaultRows) {
        expect(row.description).toBeUndefined();
        expect(row.comments).toBeUndefined();
        expect(row.historyEvents).toBeUndefined();
        expect(row.workIntervals).toBeUndefined();
        expect(row.commentCount).toBe(1);
      }

      const drillDownResult = await client.callTool(
        'task_get',
        {
          claudeDir,
          teamName: 'bulk-inventory-team',
          taskId: defaultRows[0].id,
        },
        21_1
      );
      const drillDownTask = parseJsonToolResult(
        (drillDownResult as { result: unknown }).result
      ) as Record<string, unknown>;
      expect(drillDownTask.id).toBe(defaultRows[0].id);
      expect(drillDownTask.description).toContain('Large description that must not be returned');
      expect(drillDownTask.comments).toHaveLength(1);
      expect(drillDownTask.historyEvents).toHaveLength(1);
      expect(drillDownTask.workIntervals).toHaveLength(1);

      const smallLimitResult = await client.callTool(
        'task_list',
        {
          claudeDir,
          teamName: 'bulk-inventory-team',
          limit: 7,
        },
        22
      );
      const smallLimitRows = parseJsonToolResult(
        (smallLimitResult as { result: unknown }).result
      ) as Array<Record<string, unknown>>;
      expect(smallLimitRows).toHaveLength(7);

      const filteredLimitResult = await client.callTool(
        'task_list',
        {
          claudeDir,
          teamName: 'bulk-inventory-team',
          owner: 'bob',
          limit: 5,
        },
        23
      );
      const filteredLimitRows = parseJsonToolResult(
        (filteredLimitResult as { result: unknown }).result
      ) as Array<Record<string, unknown>>;
      expect(filteredLimitRows).toHaveLength(5);
      expect(filteredLimitRows.every((row) => row.owner === 'bob')).toBe(true);

      const overLimitResult = await client.callTool(
        'task_list',
        {
          claudeDir,
          teamName: 'bulk-inventory-team',
          limit: 999,
        },
        24
      );
      const overLimitRows = parseJsonToolResult(
        (overLimitResult as { result: unknown }).result
      ) as Array<Record<string, unknown>>;
      expect(overLimitRows).toHaveLength(200);
    } finally {
      await client.close();
    }
  });

  it('applies task_list filters before default caps over stdio', async () => {
    await writeTeamConfig(claudeDir, 'filter-before-cap-team');

    for (let index = 0; index < 60; index += 1) {
      const ordinal = String(index + 1).padStart(3, '0');
      await writeInventoryTaskRow(claudeDir, 'filter-before-cap-team', {
        id: `new-alice-${ordinal}`,
        owner: 'alice',
        subject: `New alice task ${ordinal}`,
        createdAt: new Date(Date.UTC(2026, 0, 2, 0, 0, index)).toISOString(),
      });
    }

    for (let index = 0; index < 3; index += 1) {
      const ordinal = String(index + 1).padStart(3, '0');
      await writeInventoryTaskRow(claudeDir, 'filter-before-cap-team', {
        id: `old-bob-${ordinal}`,
        owner: 'bob',
        subject: `Old bob task ${ordinal}`,
        createdAt: new Date(Date.UTC(2025, 11, 31, 0, 0, index)).toISOString(),
      });
    }

    const client = new McpStdIoClient(serverPath, workspaceRoot);

    try {
      await client.initialize();

      const defaultInventoryResult = await client.callTool(
        'task_list',
        {
          claudeDir,
          teamName: 'filter-before-cap-team',
        },
        31
      );
      const defaultRows = parseJsonToolResult(
        (defaultInventoryResult as { result: unknown }).result
      ) as Array<Record<string, unknown>>;
      expect(defaultRows).toHaveLength(50);
      expect(defaultRows.some((row) => row.owner === 'bob')).toBe(false);

      const filteredInventoryResult = await client.callTool(
        'task_list',
        {
          claudeDir,
          teamName: 'filter-before-cap-team',
          owner: 'bob',
        },
        32
      );
      const filteredRows = parseJsonToolResult(
        (filteredInventoryResult as { result: unknown }).result
      ) as Array<Record<string, unknown>>;
      expect(filteredRows).toHaveLength(3);
      expect(filteredRows.map((row) => row.id).sort()).toEqual([
        'old-bob-001',
        'old-bob-002',
        'old-bob-003',
      ]);
      expect(filteredRows.every((row) => row.owner === 'bob')).toBe(true);
    } finally {
      await client.close();
    }
  });

  it('keeps task_list as active inventory and leaves deleted drill-down to task_get over stdio', async () => {
    await writeTeamConfig(claudeDir, 'deleted-inventory-team');
    const client = new McpStdIoClient(serverPath, workspaceRoot);

    try {
      await client.initialize();

      const tools = (await client.listTools()) as {
        result?: { tools?: Array<{ name: string; description?: string; inputSchema?: unknown }> };
      };
      const taskListTool = tools.result?.tools?.find((tool) => tool.name === 'task_list');
      expect(taskListTool?.description).toContain('Deleted tasks are excluded.');
      expect(JSON.stringify(taskListTool?.inputSchema)).toContain('"pending"');
      expect(JSON.stringify(taskListTool?.inputSchema)).toContain('"in_progress"');
      expect(JSON.stringify(taskListTool?.inputSchema)).toContain('"completed"');
      expect(JSON.stringify(taskListTool?.inputSchema)).not.toContain('"deleted"');

      const deletedStatusListResult = (await client.callTool(
        'task_list',
        {
          claudeDir,
          teamName: 'deleted-inventory-team',
          status: 'deleted',
        },
        40
      )) as { error?: { code?: number; message?: string } };
      expect(deletedStatusListResult.error?.code).toBe(-32602);
      expect(deletedStatusListResult.error?.message).toContain(
        'expected one of "pending"|"in_progress"|"completed"'
      );

      const createResult = await client.callTool(
        'task_create',
        {
          claudeDir,
          teamName: 'deleted-inventory-team',
          subject: 'Deleted task should not be inventory',
          owner: 'alice',
        },
        41
      );
      const task = parseJsonToolResult((createResult as { result: unknown }).result);

      await client.callTool(
        'task_set_status',
        {
          claudeDir,
          teamName: 'deleted-inventory-team',
          taskId: task.id,
          status: 'deleted',
          actor: 'alice',
        },
        42
      );

      const inventoryResult = await client.callTool(
        'task_list',
        {
          claudeDir,
          teamName: 'deleted-inventory-team',
          owner: 'alice',
        },
        43
      );
      const inventoryRows = parseJsonToolResult(
        (inventoryResult as { result: unknown }).result
      ) as Array<Record<string, unknown>>;
      expect(inventoryRows.find((row) => row.id === task.id)).toBeUndefined();

      const drillDownResult = await client.callTool(
        'task_get',
        {
          claudeDir,
          teamName: 'deleted-inventory-team',
          taskId: task.id,
        },
        44
      );
      const drillDownTask = parseJsonToolResult(
        (drillDownResult as { result: unknown }).result
      ) as Record<string, unknown>;
      expect(drillDownTask.id).toBe(task.id);
      expect(drillDownTask.status).toBe('deleted');
      expect(drillDownTask.deletedAt).toEqual(expect.any(String));
    } finally {
      await client.close();
    }
  });

  it('preserves legacy kanban reviewer fallback over stdio for old boards without review history reviewer', async () => {
    await writeTeamConfig(claudeDir, 'legacy-review-team');
    const client = new McpStdIoClient(serverPath, workspaceRoot);

    try {
      await client.initialize();

      const createResult = await client.callTool(
        'task_create',
        {
          claudeDir,
          teamName: 'legacy-review-team',
          subject: 'Legacy review fallback',
          owner: 'alice',
        },
        21
      );
      const createdTask = parseJsonToolResult((createResult as { result: unknown }).result);

      const completeResult = await client.callTool(
        'task_complete',
        {
          claudeDir,
          teamName: 'legacy-review-team',
          taskId: createdTask.id,
          actor: 'alice',
        },
        22
      );
      const completedTask = parseJsonToolResult((completeResult as { result: unknown }).result);
      expect(completedTask.status).toBe('completed');

      const taskPath = path.join(claudeDir, 'tasks', 'legacy-review-team', `${createdTask.id}.json`);
      const persistedTask = JSON.parse(await readFile(taskPath, 'utf8')) as {
        reviewState?: string;
        historyEvents?: Array<Record<string, unknown>>;
      };
      persistedTask.reviewState = 'review';
      persistedTask.historyEvents = (Array.isArray(persistedTask.historyEvents)
        ? persistedTask.historyEvents
        : []
      ).filter(
        (event) =>
          event.type !== 'review_requested' &&
          event.type !== 'review_started' &&
          event.type !== 'review_approved' &&
          event.type !== 'review_changes_requested'
      );
      await writeFile(taskPath, JSON.stringify(persistedTask, null, 2), 'utf8');

      const kanbanPath = path.join(claudeDir, 'teams', 'legacy-review-team', 'kanban-state.json');
      await writeFile(
        kanbanPath,
        JSON.stringify(
          {
            teamName: 'legacy-review-team',
            reviewers: [],
            tasks: {
              [createdTask.id]: {
                column: 'review',
                reviewer: 'bob',
                movedAt: '2026-01-01T00:00:00.000Z',
              },
            },
            columnOrder: {
              review: [createdTask.id],
            },
          },
          null,
          2
        ),
        'utf8'
      );

      const reviewerBriefingResult = await client.callTool(
        'task_briefing',
        {
          claudeDir,
          teamName: 'legacy-review-team',
          memberName: 'bob',
        },
        23
      );
      const reviewerBriefingText = (
        ((reviewerBriefingResult as { result: { content?: Array<{ text?: string }> } }).result
          ?.content?.[0]?.text as string | undefined) ?? ''
      );
      expect(reviewerBriefingText).toContain('Task briefing for bob:');
      expect(reviewerBriefingText).toContain('Actionable:');
      expect(reviewerBriefingText).toContain(`#${createdTask.displayId}`);
      expect(reviewerBriefingText).toContain('reviewer=bob');
      expect(reviewerBriefingText).not.toContain('review_reviewer_missing');

      const leadBriefingResult = await client.callTool(
        'lead_briefing',
        {
          claudeDir,
          teamName: 'legacy-review-team',
        },
        24
      );
      const leadBriefingText = (
        ((leadBriefingResult as { result: { content?: Array<{ text?: string }> } }).result
          ?.content?.[0]?.text as string | undefined) ?? ''
      );
      expect(leadBriefingText).toContain('Lead queue for team-lead on team "legacy-review-team":');
      expect(leadBriefingText).toContain('Watching:');
      expect(leadBriefingText).toContain(`#${createdTask.displayId}`);
      expect(leadBriefingText).not.toContain('review_reviewer_missing');

      const inventoryResult = await client.callTool(
        'task_list',
        {
          claudeDir,
          teamName: 'legacy-review-team',
          reviewState: 'review',
          kanbanColumn: 'review',
        },
        25
      );
      const inventoryRows = parseJsonToolResult((inventoryResult as { result: unknown }).result);
      expect(inventoryRows).toHaveLength(1);
      expect(inventoryRows[0]).toMatchObject({
        id: createdTask.id,
        owner: 'alice',
        reviewState: 'review',
        status: 'completed',
      });
    } finally {
      await client.close();
    }
  });

  it('surfaces reviewer-assignment gaps and needs-fix review roundtrip over stdio', async () => {
    await writeTeamConfig(claudeDir, 'review-roundtrip-team');
    const client = new McpStdIoClient(serverPath, workspaceRoot);

    try {
      await client.initialize();

      const noReviewerCreateResult = await client.callTool(
        'task_create',
        {
          claudeDir,
          teamName: 'review-roundtrip-team',
          subject: 'Needs reviewer assignment',
          owner: 'alice',
        },
        31
      );
      const noReviewerTask = parseJsonToolResult(
        (noReviewerCreateResult as { result: unknown }).result
      );

      await client.callTool(
        'task_complete',
        {
          claudeDir,
          teamName: 'review-roundtrip-team',
          taskId: noReviewerTask.id,
          actor: 'alice',
        },
        32
      );

      const noReviewerRequestResult = await client.callTool(
        'review_request',
        {
          claudeDir,
          teamName: 'review-roundtrip-team',
          taskId: noReviewerTask.id,
          from: 'team-lead',
        },
        33
      );
      const noReviewerRequestedTask = parseJsonToolResult(
        (noReviewerRequestResult as { result: unknown }).result
      );
      expect(noReviewerRequestedTask.reviewState).toBe('review');

      const leadAssignmentBriefingResult = await client.callTool(
        'lead_briefing',
        {
          claudeDir,
          teamName: 'review-roundtrip-team',
        },
        34
      );
      const leadAssignmentBriefingText = (
        ((leadAssignmentBriefingResult as { result: { content?: Array<{ text?: string }> } }).result
          ?.content?.[0]?.text as string | undefined) ?? ''
      );
      expect(leadAssignmentBriefingText).toContain('Needs reviewer assignment:');
      expect(leadAssignmentBriefingText).toContain(`#${noReviewerTask.displayId}`);
      expect(leadAssignmentBriefingText).toContain('reason=review_reviewer_missing');

      const reviewerEmptyBriefingResult = await client.callTool(
        'task_briefing',
        {
          claudeDir,
          teamName: 'review-roundtrip-team',
          memberName: 'bob',
        },
        35
      );
      const reviewerEmptyBriefingText = (
        ((reviewerEmptyBriefingResult as { result: { content?: Array<{ text?: string }> } }).result
          ?.content?.[0]?.text as string | undefined) ?? ''
      );
      expect(reviewerEmptyBriefingText).toContain('No actionable or awareness tasks for bob.');
      expect(reviewerEmptyBriefingText).not.toContain(`#${noReviewerTask.displayId}`);

      const roundtripCreateResult = await client.callTool(
        'task_create',
        {
          claudeDir,
          teamName: 'review-roundtrip-team',
          subject: 'Needs fixes after review',
          owner: 'alice',
          description: 'Roundtrip description',
        },
        36
      );
      const roundtripTask = parseJsonToolResult((roundtripCreateResult as { result: unknown }).result);

      await client.callTool(
        'task_complete',
        {
          claudeDir,
          teamName: 'review-roundtrip-team',
          taskId: roundtripTask.id,
          actor: 'alice',
        },
        37
      );

      await client.callTool(
        'review_request',
        {
          claudeDir,
          teamName: 'review-roundtrip-team',
          taskId: roundtripTask.id,
          from: 'team-lead',
          reviewer: 'bob',
        },
        38
      );

      await client.callTool(
        'review_start',
        {
          claudeDir,
          teamName: 'review-roundtrip-team',
          taskId: roundtripTask.id,
        },
        39
      );

      const reviewerActiveBriefingResult = await client.callTool(
        'task_briefing',
        {
          claudeDir,
          teamName: 'review-roundtrip-team',
          memberName: 'bob',
        },
        40
      );
      const reviewerActiveBriefingText = (
        ((reviewerActiveBriefingResult as { result: { content?: Array<{ text?: string }> } }).result
          ?.content?.[0]?.text as string | undefined) ?? ''
      );
      expect(reviewerActiveBriefingText).toContain(`#${roundtripTask.displayId}`);
      expect(reviewerActiveBriefingText).toContain('reason=review_in_progress');
      expect(reviewerActiveBriefingText).toContain('reviewer=bob');

      const changesResult = await client.callTool(
        'review_request_changes',
        {
          claudeDir,
          teamName: 'review-roundtrip-team',
          taskId: roundtripTask.id,
          from: 'bob',
          comment: 'Please fix the failing edge case.',
        },
        41
      );
      const changedTask = parseJsonToolResult((changesResult as { result: unknown }).result);
      expect(changedTask.status).toBe('pending');
      expect(changedTask.reviewState).toBe('needsFix');

      const ownerNeedsFixBriefingResult = await client.callTool(
        'task_briefing',
        {
          claudeDir,
          teamName: 'review-roundtrip-team',
          memberName: 'alice',
        },
        42
      );
      const ownerNeedsFixBriefingText = (
        ((ownerNeedsFixBriefingResult as { result: { content?: Array<{ text?: string }> } }).result
          ?.content?.[0]?.text as string | undefined) ?? ''
      );
      expect(ownerNeedsFixBriefingText).toContain(`#${roundtripTask.displayId}`);
      expect(ownerNeedsFixBriefingText).toContain('Actionable:');
      expect(ownerNeedsFixBriefingText).toContain('reason=needs_fix');
      expect(ownerNeedsFixBriefingText).toContain('Description: Roundtrip description');
      expect(ownerNeedsFixBriefingText).toContain('Please fix the failing edge case.');

      const needsFixInventoryResult = await client.callTool(
        'task_list',
        {
          claudeDir,
          teamName: 'review-roundtrip-team',
          owner: 'alice',
          reviewState: 'needsFix',
          status: 'pending',
        },
        43
      );
      const needsFixInventoryRows = parseJsonToolResult(
        (needsFixInventoryResult as { result: unknown }).result
      );
      expect(needsFixInventoryRows).toHaveLength(1);
      expect(needsFixInventoryRows[0]).toMatchObject({
        id: roundtripTask.id,
        owner: 'alice',
        reviewState: 'needsFix',
        status: 'pending',
      });

      const finalLeadBriefingResult = await client.callTool(
        'lead_briefing',
        {
          claudeDir,
          teamName: 'review-roundtrip-team',
        },
        44
      );
      const finalLeadBriefingText = (
        ((finalLeadBriefingResult as { result: { content?: Array<{ text?: string }> } }).result
          ?.content?.[0]?.text as string | undefined) ?? ''
      );
      expect(finalLeadBriefingText).toContain(`#${noReviewerTask.displayId}`);
      expect(finalLeadBriefingText).not.toContain(`#${roundtripTask.displayId}`);
    } finally {
      await client.close();
    }
  });

  it('surfaces self-review invalid as lead-owned and supports relationship inventory filters over stdio', async () => {
    await writeTeamConfig(claudeDir, 'inventory-filters-team');
    const client = new McpStdIoClient(serverPath, workspaceRoot);

    try {
      await client.initialize();

      const baseCreateResult = await client.callTool(
        'task_create',
        {
          claudeDir,
          teamName: 'inventory-filters-team',
          subject: 'Base task',
          owner: 'alice',
        },
        51
      );
      const baseTask = parseJsonToolResult((baseCreateResult as { result: unknown }).result);

      const blockedCreateResult = await client.callTool(
        'task_create',
        {
          claudeDir,
          teamName: 'inventory-filters-team',
          subject: 'Blocked task',
          owner: 'alice',
          blockedBy: [baseTask.id],
        },
        52
      );
      const blockedTask = parseJsonToolResult((blockedCreateResult as { result: unknown }).result);

      const relatedCreateResult = await client.callTool(
        'task_create',
        {
          claudeDir,
          teamName: 'inventory-filters-team',
          subject: 'Related task',
          owner: 'alice',
          related: [baseTask.id],
        },
        53
      );
      const relatedTask = parseJsonToolResult((relatedCreateResult as { result: unknown }).result);

      const blockedInventoryResult = await client.callTool(
        'task_list',
        {
          claudeDir,
          teamName: 'inventory-filters-team',
          blockedBy: `#${baseTask.displayId}`,
        },
        54
      );
      const blockedInventoryRows = parseJsonToolResult(
        (blockedInventoryResult as { result: unknown }).result
      );
      expect(blockedInventoryRows).toHaveLength(1);
      expect(blockedInventoryRows[0]).toMatchObject({
        id: blockedTask.id,
        subject: 'Blocked task',
        blockedBy: [baseTask.id],
      });

      const relatedInventoryResult = await client.callTool(
        'task_list',
        {
          claudeDir,
          teamName: 'inventory-filters-team',
          relatedTo: `#${baseTask.displayId}`,
        },
        55
      );
      const relatedInventoryRows = parseJsonToolResult(
        (relatedInventoryResult as { result: unknown }).result
      );
      expect(relatedInventoryRows).toHaveLength(1);
      expect(relatedInventoryRows[0]).toMatchObject({
        id: relatedTask.id,
        subject: 'Related task',
        related: [baseTask.id],
      });

      const blockedOwnerBriefingResult = await client.callTool(
        'task_briefing',
        {
          claudeDir,
          teamName: 'inventory-filters-team',
          memberName: 'alice',
        },
        55_1
      );
      const blockedOwnerBriefingText = (
        ((blockedOwnerBriefingResult as { result: { content?: Array<{ text?: string }> } }).result
          ?.content?.[0]?.text as string | undefined) ?? ''
      );
      expect(blockedOwnerBriefingText).toContain(`#${baseTask.displayId}`);
      expect(blockedOwnerBriefingText).toContain('Actionable:');
      expect(blockedOwnerBriefingText).toContain(`#${blockedTask.displayId}`);
      expect(blockedOwnerBriefingText).toContain('Awareness:');
      expect(blockedOwnerBriefingText).toContain('reason=dependency_waiting');

      await client.callTool(
        'task_complete',
        {
          claudeDir,
          teamName: 'inventory-filters-team',
          taskId: baseTask.id,
          actor: 'alice',
        },
        55_2
      );

      const unblockedOwnerBriefingResult = await client.callTool(
        'task_briefing',
        {
          claudeDir,
          teamName: 'inventory-filters-team',
          memberName: 'alice',
        },
        55_3
      );
      const unblockedOwnerBriefingText = (
        ((unblockedOwnerBriefingResult as { result: { content?: Array<{ text?: string }> } }).result
          ?.content?.[0]?.text as string | undefined) ?? ''
      );
      expect(unblockedOwnerBriefingText).toContain(`#${blockedTask.displayId}`);
      expect(unblockedOwnerBriefingText).toContain('Actionable:');
      expect(unblockedOwnerBriefingText).toContain('reason=owner_ready');
      expect(unblockedOwnerBriefingText).not.toContain('reason=dependency_waiting');

      const selfReviewCreateResult = await client.callTool(
        'task_create',
        {
          claudeDir,
          teamName: 'inventory-filters-team',
          subject: 'Self review should be invalid',
          owner: 'alice',
        },
        56
      );
      const selfReviewTask = parseJsonToolResult(
        (selfReviewCreateResult as { result: unknown }).result
      );

      await client.callTool(
        'task_complete',
        {
          claudeDir,
          teamName: 'inventory-filters-team',
          taskId: selfReviewTask.id,
          actor: 'alice',
        },
        57
      );

      await client.callTool(
        'review_request',
        {
          claudeDir,
          teamName: 'inventory-filters-team',
          taskId: selfReviewTask.id,
          from: 'team-lead',
          reviewer: 'alice',
        },
        58
      );

      const leadBriefingResult = await client.callTool(
        'lead_briefing',
        {
          claudeDir,
          teamName: 'inventory-filters-team',
        },
        59
      );
      const leadBriefingText = (
        ((leadBriefingResult as { result: { content?: Array<{ text?: string }> } }).result
          ?.content?.[0]?.text as string | undefined) ?? ''
      );
      expect(leadBriefingText).toContain('Needs reviewer assignment:');
      expect(leadBriefingText).toContain(`#${selfReviewTask.displayId}`);
      expect(leadBriefingText).toContain('reason=self_review_invalid');

      const ownerBriefingResult = await client.callTool(
        'task_briefing',
        {
          claudeDir,
          teamName: 'inventory-filters-team',
          memberName: 'alice',
        },
        60
      );
      const ownerBriefingText = (
        ((ownerBriefingResult as { result: { content?: Array<{ text?: string }> } }).result
          ?.content?.[0]?.text as string | undefined) ?? ''
      );
      expect(ownerBriefingText).toContain(`#${selfReviewTask.displayId}`);
      expect(ownerBriefingText).toContain('Awareness:');
      expect(ownerBriefingText).toContain('reason=self_review_invalid');
    } finally {
      await client.close();
    }
  });

  it('routes clarification flags into owner awareness and lead sections over stdio', async () => {
    await writeTeamConfig(claudeDir, 'clarification-team');
    const client = new McpStdIoClient(serverPath, workspaceRoot);

    try {
      await client.initialize();

      const leadClarificationCreateResult = await client.callTool(
        'task_create',
        {
          claudeDir,
          teamName: 'clarification-team',
          subject: 'Need lead answer',
          owner: 'alice',
        },
        71
      );
      const leadClarificationTask = parseJsonToolResult(
        (leadClarificationCreateResult as { result: unknown }).result
      );

      const userClarificationCreateResult = await client.callTool(
        'task_create',
        {
          claudeDir,
          teamName: 'clarification-team',
          subject: 'Need user answer',
          owner: 'alice',
        },
        72
      );
      const userClarificationTask = parseJsonToolResult(
        (userClarificationCreateResult as { result: unknown }).result
      );

      await client.callTool(
        'task_set_clarification',
        {
          claudeDir,
          teamName: 'clarification-team',
          taskId: leadClarificationTask.id,
          value: 'lead',
        },
        73
      );

      await client.callTool(
        'task_set_clarification',
        {
          claudeDir,
          teamName: 'clarification-team',
          taskId: userClarificationTask.id,
          value: 'user',
        },
        74
      );

      const ownerBriefingResult = await client.callTool(
        'task_briefing',
        {
          claudeDir,
          teamName: 'clarification-team',
          memberName: 'alice',
        },
        75
      );
      const ownerBriefingText = (
        ((ownerBriefingResult as { result: { content?: Array<{ text?: string }> } }).result
          ?.content?.[0]?.text as string | undefined) ?? ''
      );
      expect(ownerBriefingText).toContain('Awareness:');
      expect(ownerBriefingText).toContain(`#${leadClarificationTask.displayId}`);
      expect(ownerBriefingText).toContain('reason=waiting_lead_clarification');
      expect(ownerBriefingText).toContain('clarification=lead');
      expect(ownerBriefingText).toContain(`#${userClarificationTask.displayId}`);
      expect(ownerBriefingText).toContain('reason=waiting_user_clarification');
      expect(ownerBriefingText).toContain('clarification=user');

      const leadBriefingResult = await client.callTool(
        'lead_briefing',
        {
          claudeDir,
          teamName: 'clarification-team',
        },
        76
      );
      const leadBriefingText = (
        ((leadBriefingResult as { result: { content?: Array<{ text?: string }> } }).result
          ?.content?.[0]?.text as string | undefined) ?? ''
      );
      expect(leadBriefingText).toContain('Needs clarification from lead:');
      expect(leadBriefingText).toContain(`#${leadClarificationTask.displayId}`);
      expect(leadBriefingText).toContain('reason=waiting_lead_clarification');
      expect(leadBriefingText).toContain('Waiting on user:');
      expect(leadBriefingText).toContain(`#${userClarificationTask.displayId}`);
      expect(leadBriefingText).toContain('reason=waiting_user_clarification');

      const inventoryResult = await client.callTool(
        'task_list',
        {
          claudeDir,
          teamName: 'clarification-team',
          owner: 'alice',
          status: 'pending',
        },
        77
      );
      const inventoryRows = parseJsonToolResult((inventoryResult as { result: unknown }).result);
      const leadClarificationRow = inventoryRows.find(
        (row: { id: string }) => row.id === leadClarificationTask.id
      ) as Record<string, unknown> | undefined;
      const userClarificationRow = inventoryRows.find(
        (row: { id: string }) => row.id === userClarificationTask.id
      ) as Record<string, unknown> | undefined;
      expect(leadClarificationRow?.needsClarification).toBe('lead');
      expect(userClarificationRow?.needsClarification).toBe('user');

      await client.callTool(
        'task_set_clarification',
        {
          claudeDir,
          teamName: 'clarification-team',
          taskId: leadClarificationTask.id,
          value: 'clear',
        },
        78
      );

      const ownerAfterClearBriefingResult = await client.callTool(
        'task_briefing',
        {
          claudeDir,
          teamName: 'clarification-team',
          memberName: 'alice',
        },
        79
      );
      const ownerAfterClearBriefingText = (
        ((ownerAfterClearBriefingResult as { result: { content?: Array<{ text?: string }> } }).result
          ?.content?.[0]?.text as string | undefined) ?? ''
      );
      expect(ownerAfterClearBriefingText).toContain('Actionable:');
      expect(ownerAfterClearBriefingText).toContain(`#${leadClarificationTask.displayId}`);
      expect(ownerAfterClearBriefingText).toContain('reason=owner_ready');
      expect(ownerAfterClearBriefingText).not.toContain('reason=waiting_lead_clarification');
      expect(ownerAfterClearBriefingText).toContain(`#${userClarificationTask.displayId}`);
      expect(ownerAfterClearBriefingText).toContain('reason=waiting_user_clarification');

      const leadAfterClearBriefingResult = await client.callTool(
        'lead_briefing',
        {
          claudeDir,
          teamName: 'clarification-team',
        },
        80
      );
      const leadAfterClearBriefingText = (
        ((leadAfterClearBriefingResult as { result: { content?: Array<{ text?: string }> } }).result
          ?.content?.[0]?.text as string | undefined) ?? ''
      );
      expect(leadAfterClearBriefingText).not.toContain(`#${leadClarificationTask.displayId}`);
      expect(leadAfterClearBriefingText).toContain('Waiting on user:');
      expect(leadAfterClearBriefingText).toContain(`#${userClarificationTask.displayId}`);
    } finally {
      await client.close();
    }
  });

  it('routes lead-owned work and approved terminal awareness over stdio', async () => {
    await writeTeamConfig(claudeDir, 'terminal-routing-team');
    const client = new McpStdIoClient(serverPath, workspaceRoot);

    try {
      await client.initialize();

      const leadOwnedCreateResult = await client.callTool(
        'task_create',
        {
          claudeDir,
          teamName: 'terminal-routing-team',
          subject: 'Lead-owned follow-up task',
          owner: 'team-lead',
        },
        81
      );
      const leadOwnedTask = parseJsonToolResult(
        (leadOwnedCreateResult as { result: unknown }).result
      );

      const leadOwnedBriefingResult = await client.callTool(
        'lead_briefing',
        {
          claudeDir,
          teamName: 'terminal-routing-team',
        },
        82
      );
      const leadOwnedBriefingText = (
        ((leadOwnedBriefingResult as { result: { content?: Array<{ text?: string }> } }).result
          ?.content?.[0]?.text as string | undefined) ?? ''
      );
      expect(leadOwnedBriefingText).toContain('Lead-owned follow-up:');
      expect(leadOwnedBriefingText).toContain(`#${leadOwnedTask.displayId}`);
      expect(leadOwnedBriefingText).toContain('owner=team-lead');
      expect(leadOwnedBriefingText).toContain('actionOwner=lead');
      expect(leadOwnedBriefingText).toContain('reason=owner_ready');

      const unrelatedMemberBriefingResult = await client.callTool(
        'task_briefing',
        {
          claudeDir,
          teamName: 'terminal-routing-team',
          memberName: 'alice',
        },
        83
      );
      const unrelatedMemberBriefingText = (
        ((unrelatedMemberBriefingResult as { result: { content?: Array<{ text?: string }> } }).result
          ?.content?.[0]?.text as string | undefined) ?? ''
      );
      expect(unrelatedMemberBriefingText).toContain('No actionable or awareness tasks for alice.');
      expect(unrelatedMemberBriefingText).not.toContain(`#${leadOwnedTask.displayId}`);

      const approvedCreateResult = await client.callTool(
        'task_create',
        {
          claudeDir,
          teamName: 'terminal-routing-team',
          subject: 'Approved terminal task',
          owner: 'alice',
          description: 'This should become terminal awareness, not work.',
        },
        84
      );
      const approvedTask = parseJsonToolResult((approvedCreateResult as { result: unknown }).result);

      await client.callTool(
        'task_complete',
        {
          claudeDir,
          teamName: 'terminal-routing-team',
          taskId: approvedTask.id,
          actor: 'alice',
        },
        85
      );

      await client.callTool(
        'review_request',
        {
          claudeDir,
          teamName: 'terminal-routing-team',
          taskId: approvedTask.id,
          from: 'team-lead',
          reviewer: 'bob',
        },
        86
      );

      await client.callTool(
        'review_start',
        {
          claudeDir,
          teamName: 'terminal-routing-team',
          taskId: approvedTask.id,
        },
        87
      );

      const approveResult = await client.callTool(
        'review_approve',
        {
          claudeDir,
          teamName: 'terminal-routing-team',
          taskId: approvedTask.id,
          from: 'bob',
          note: 'Approved through stdio e2e.',
          notifyOwner: true,
        },
        88
      );
      const approvedPayload = parseJsonToolResult((approveResult as { result: unknown }).result);
      expect(approvedPayload.reviewState).toBe('approved');

      const ownerBriefingResult = await client.callTool(
        'task_briefing',
        {
          claudeDir,
          teamName: 'terminal-routing-team',
          memberName: 'alice',
        },
        89
      );
      const ownerBriefingText = (
        ((ownerBriefingResult as { result: { content?: Array<{ text?: string }> } }).result
          ?.content?.[0]?.text as string | undefined) ?? ''
      );
      expect(ownerBriefingText).not.toContain('Actionable:');
      expect(ownerBriefingText).toContain('Awareness:');
      expect(ownerBriefingText).toContain(`#${approvedTask.displayId}`);
      expect(ownerBriefingText).toContain('review=approved');
      expect(ownerBriefingText).toContain('actionOwner=none');
      expect(ownerBriefingText).toContain('reason=terminal_approved');
      expect(ownerBriefingText).not.toContain('Description: This should become terminal awareness');

      const leadAfterApprovalBriefingResult = await client.callTool(
        'lead_briefing',
        {
          claudeDir,
          teamName: 'terminal-routing-team',
        },
        90
      );
      const leadAfterApprovalBriefingText = (
        ((leadAfterApprovalBriefingResult as { result: { content?: Array<{ text?: string }> } }).result
          ?.content?.[0]?.text as string | undefined) ?? ''
      );
      expect(leadAfterApprovalBriefingText).toContain(`#${leadOwnedTask.displayId}`);
      expect(leadAfterApprovalBriefingText).not.toContain(`#${approvedTask.displayId}`);

      const approvedInventoryResult = await client.callTool(
        'task_list',
        {
          claudeDir,
          teamName: 'terminal-routing-team',
          reviewState: 'approved',
          kanbanColumn: 'approved',
        },
        91
      );
      const approvedInventoryRows = parseJsonToolResult(
        (approvedInventoryResult as { result: unknown }).result
      );
      expect(approvedInventoryRows).toHaveLength(1);
      expect(approvedInventoryRows[0]).toMatchObject({
        id: approvedTask.id,
        owner: 'alice',
        status: 'completed',
        reviewState: 'approved',
      });
      expect(approvedInventoryRows[0].description).toBeUndefined();
      expect(approvedInventoryRows[0].comments).toBeUndefined();
      expect(approvedInventoryRows[0].historyEvents).toBeUndefined();
    } finally {
      await client.close();
    }
  });

  it('routes invalid owners and broken dependencies to lead over stdio', async () => {
    await writeTeamConfig(claudeDir, 'repair-team');
    const client = new McpStdIoClient(serverPath, workspaceRoot);

    try {
      await client.initialize();

      const orphanedTaskResult = await client.callTool(
        'task_create',
        {
          claudeDir,
          teamName: 'repair-team',
          subject: 'Owner became invalid',
          owner: 'alice',
        },
        81
      );
      const orphanedTask = parseJsonToolResult((orphanedTaskResult as { result: unknown }).result);

      const membersMetaPath = path.join(claudeDir, 'teams', 'repair-team', 'members.meta.json');
      await writeFile(
        membersMetaPath,
        JSON.stringify(
          {
            version: 1,
            members: [{ name: 'alice', removedAt: 1_776_772_800_000 }],
          },
          null,
          2
        ),
        'utf8'
      );

      const dependencyTaskResult = await client.callTool(
        'task_create',
        {
          claudeDir,
          teamName: 'repair-team',
          subject: 'Dependency to be deleted',
          owner: 'bob',
        },
        82
      );
      const dependencyTask = parseJsonToolResult(
        (dependencyTaskResult as { result: unknown }).result
      );

      const blockedTaskResult = await client.callTool(
        'task_create',
        {
          claudeDir,
          teamName: 'repair-team',
          subject: 'Broken dependency task',
          owner: 'bob',
          blockedBy: [dependencyTask.id],
        },
        83
      );
      const blockedTask = parseJsonToolResult((blockedTaskResult as { result: unknown }).result);

      await client.callTool(
        'task_set_status',
        {
          claudeDir,
          teamName: 'repair-team',
          taskId: dependencyTask.id,
          status: 'deleted',
          actor: 'bob',
        },
        84
      );

      const leadBriefingResult = await client.callTool(
        'lead_briefing',
        {
          claudeDir,
          teamName: 'repair-team',
        },
        85
      );
      const leadBriefingText = (
        ((leadBriefingResult as { result: { content?: Array<{ text?: string }> } }).result
          ?.content?.[0]?.text as string | undefined) ?? ''
      );
      expect(leadBriefingText).toContain('Needs owner assignment:');
      expect(leadBriefingText).toContain(`#${orphanedTask.displayId}`);
      expect(leadBriefingText).toContain('reason=owner_invalid');
      expect(leadBriefingText).toContain('Dependency repair:');
      expect(leadBriefingText).toContain(`#${blockedTask.displayId}`);
      expect(leadBriefingText).toContain('reason=dependency_broken');

      const bobBriefingResult = await client.callTool(
        'task_briefing',
        {
          claudeDir,
          teamName: 'repair-team',
          memberName: 'bob',
        },
        86
      );
      const bobBriefingText = (
        ((bobBriefingResult as { result: { content?: Array<{ text?: string }> } }).result
          ?.content?.[0]?.text as string | undefined) ?? ''
      );
      expect(bobBriefingText).toContain('Awareness:');
      expect(bobBriefingText).toContain(`#${blockedTask.displayId}`);
      expect(bobBriefingText).toContain('reason=dependency_broken');
      expect(bobBriefingText).not.toContain('reason=owner_ready');

      const inventoryResult = await client.callTool(
        'task_list',
        {
          claudeDir,
          teamName: 'repair-team',
          owner: 'bob',
        },
        87
      );
      const inventoryRows = parseJsonToolResult((inventoryResult as { result: unknown }).result);
      const blockedRow = inventoryRows.find(
        (row: { id: string }) => row.id === blockedTask.id
      ) as Record<string, unknown> | undefined;
      expect(blockedRow).toMatchObject({
        id: blockedTask.id,
        owner: 'bob',
        blockedBy: [dependencyTask.id],
        status: 'pending',
      });
    } finally {
      await client.close();
    }
  });

  it('guards review lifecycle bypasses and deleted resurrection over stdio', async () => {
    await writeTeamConfig(claudeDir, 'stdio-hardening-team');
    const client = new McpStdIoClient(serverPath, workspaceRoot);

    try {
      await client.initialize();

      const createResult = await client.callTool(
        'task_create',
        {
          claudeDir,
          teamName: 'stdio-hardening-team',
          subject: 'Lifecycle guard task',
          owner: 'alice',
        },
        101
      );
      const task = parseJsonToolResult((createResult as { result: unknown }).result);

      await client.callTool(
        'task_complete',
        {
          claudeDir,
          teamName: 'stdio-hardening-team',
          taskId: task.id,
          actor: 'alice',
        },
        102
      );
      await client.callTool(
        'review_request',
        {
          claudeDir,
          teamName: 'stdio-hardening-team',
          taskId: task.id,
          from: 'team-lead',
          reviewer: 'bob',
        },
        103
      );
      await client.callTool(
        'review_approve',
        {
          claudeDir,
          teamName: 'stdio-hardening-team',
          taskId: task.id,
          from: 'bob',
        },
        104
      );

      const clearResult = await client.callTool(
        'kanban_clear',
        {
          claudeDir,
          teamName: 'stdio-hardening-team',
          taskId: task.id,
        },
        105
      );
      const clearResponse = clearResult as {
        error?: { message?: string };
        result?: { content?: Array<{ text?: string }> };
      };
      const clearErrorText =
        clearResponse.error?.message ?? (clearResponse.result?.content?.[0]?.text ?? '');
      expect(clearErrorText).toContain('reviewState=approved');

      const reopenedResult = await client.callTool(
        'task_set_status',
        {
          claudeDir,
          teamName: 'stdio-hardening-team',
          taskId: task.id,
          status: 'pending',
          actor: 'team-lead',
        },
        106
      );
      const reopened = parseJsonToolResult((reopenedResult as { result: unknown }).result);
      expect(reopened.status).toBe('pending');
      expect(reopened.reviewState).toBe('none');

      const inventoryResult = await client.callTool(
        'task_list',
        {
          claudeDir,
          teamName: 'stdio-hardening-team',
          owner: 'alice',
        },
        107
      );
      const inventoryRows = parseJsonToolResult((inventoryResult as { result: unknown }).result);
      expect(inventoryRows[0]).toMatchObject({
        id: task.id,
        status: 'pending',
        reviewState: 'none',
      });

      const deleteResult = await client.callTool(
        'task_set_status',
        {
          claudeDir,
          teamName: 'stdio-hardening-team',
          taskId: task.id,
          status: 'deleted',
          actor: 'team-lead',
        },
        108
      );
      const deleted = parseJsonToolResult((deleteResult as { result: unknown }).result);
      expect(deleted.status).toBe('deleted');
      expect(deleted.reviewState).toBe('none');

      const startDeletedResult = await client.callTool(
        'task_start',
        {
          claudeDir,
          teamName: 'stdio-hardening-team',
          taskId: task.id,
          actor: 'alice',
        },
        109
      );
      const startDeletedResponse = startDeletedResult as {
        error?: { message?: string };
        result?: { content?: Array<{ text?: string }> };
      };
      const startDeletedErrorText =
        startDeletedResponse.error?.message ?? (startDeletedResponse.result?.content?.[0]?.text ?? '');
      expect(startDeletedErrorText).toContain('use task_restore before starting work');

      const restoreResult = await client.callTool(
        'task_restore',
        {
          claudeDir,
          teamName: 'stdio-hardening-team',
          taskId: task.id,
          actor: 'team-lead',
        },
        110
      );
      const restored = parseJsonToolResult((restoreResult as { result: unknown }).result);
      expect(restored.status).toBe('pending');
      expect(restored.reviewState).toBe('none');

      const restoreAgainResult = await client.callTool(
        'task_restore',
        {
          claudeDir,
          teamName: 'stdio-hardening-team',
          taskId: task.id,
          actor: 'team-lead',
        },
        111
      );
      const restoreAgainResponse = restoreAgainResult as {
        error?: { message?: string };
        result?: { content?: Array<{ text?: string }> };
      };
      const restoreAgainErrorText =
        restoreAgainResponse.error?.message ?? (restoreAgainResponse.result?.content?.[0]?.text ?? '');
      expect(restoreAgainErrorText).toContain('task_restore only restores deleted tasks');
    } finally {
      await client.close();
    }
  });
});