export interface SwarmId {
  id: string;
  namespace: string;
  version: string;
  createdAt: Date;
}

export interface AgentId {
  id: string;
  swarmId: string;
  type: AgentType;
  instance: number;
}

interface AgentInput {
  description: string;
  prompt: string;
  subagent_type: string;
  name?: string;           // ← Teammate name
  team_name?: string;      // ← Team to join
  mode?: "plan" | "default";
}

export type TopologyType = 'mesh' | 'hierarchical' | 'centralized' | 'hybrid';

export interface TopologyConfig {
  type: TopologyType;
  maxAgents: number;
  replicationFactor?: number;
  partitionStrategy?: 'hash' | 'range' | 'round-robin';
  failoverEnabled?: boolean;
  autoRebalance?: boolean;
}

"in_process_teammate" (18 refs) → In-process execution
"tmux" (26 refs) → tmux spawn backend
"hierarchical" topology support
"flat" topology support

export type AgentType =
  | 'coordinator'
  | 'researcher'
  | 'coder'
  | 'analyst'
  | 'architect'
  | 'tester'
  | 'reviewer'
  | 'optimizer'
  | 'documenter'
  | 'monitor'
  | 'specialist'
  | 'queen'
  | 'worker';

subagent_type field supports same agent types
60+ agent types defined in CLAUDE.md configuration

export interface AgentState {
  id: AgentId;
  name: string;
  type: AgentType;
  status: AgentStatus;
  capabilities: AgentCapabilities;
  metrics: AgentMetrics;
  currentTask?: TaskId;
  workload: number;
  health: number;
  lastHeartbeat: Date;
  topologyRole?: TopologyNode['role'];
  connections: string[];
}

interface TeammateInfo {
  id: string;
  name: string;
  role: string;
  status: 'active' | 'idle' | 'busy' | 'shutdown_pending';
  spawnedAt: Date;
  messagesSent: number;
  messagesReceived: number;
  currentTask?: string;
}

export type MessageType =
  | 'task_assign'
  | 'task_complete'
  | 'task_fail'
  | 'heartbeat'
  | 'status_update'
  | 'consensus_propose'
  | 'consensus_vote'
  | 'consensus_commit'
  | 'topology_update'
  | 'agent_join'
  | 'agent_leave'
  | 'broadcast'
  | 'direct';

export interface Message {
  id: string;
  type: MessageType;
  from: string;
  to: string | 'broadcast';  // ← Same pattern!
  payload: unknown;
  timestamp: Date;
  priority: 'urgent' | 'high' | 'normal' | 'low';
  requiresAck: boolean;
  ttlMs: number;
}

"write" (42 refs) → Send to specific teammate
"broadcast" (42 refs) → Send to all teammates
"teammate_mailbox" (3 refs) → Message storage

Coordinator → MessageBus.broadcast() → All Agents
Agent → MessageBus.send() → Specific Agent
Agent → MessageBus.subscribe() → Receive messages

Coordinator → TeammateTool.broadcast → All Teammates
Teammate → TeammateTool.write → Specific Teammate
Teammate → Mailbox polling → Receive messages

export type ConsensusAlgorithm = 'raft' | 'byzantine' | 'gossip' | 'paxos';

export interface ConsensusConfig {
  algorithm: ConsensusAlgorithm;
  threshold: number;
  timeoutMs: number;
  maxRounds: number;
  requireQuorum: boolean;
}

export interface ConsensusProposal {
  id: string;
  proposerId: string;
  value: unknown;
  term: number;
  timestamp: Date;
  votes: Map<string, ConsensusVote>;
  status: 'pending' | 'accepted' | 'rejected' | 'expired';
}

export interface ConsensusVote {
  voterId: string;
  approve: boolean;
  confidence: number;
  timestamp: Date;
  reason?: string;
}

"approvePlan" (12 refs)
"rejectPlan" (13 refs)
"requestShutdown" (14 refs) → Needs approval
"approveShutdown" (9 refs)
"rejectJoin" (11 refs)
"approveJoin" (12 refs)

// Queen analyzes task and creates plan
const analysis = await queen.analyzeTask(task);
// Plan decomposed into subtasks
const subtasks = analysis.subtasks;
// Consensus on execution
const result = await coordinator.proposeConsensus(subtasks);
// Execute after approval
if (result.approved) {
  await coordinator.executePlan(subtasks);
}

interface ExitPlanModeInput {
  allowedPrompts?: { tool: "Bash"; prompt: string }[];
  pushToRemote?: boolean;
  launchSwarm?: boolean;      // ← Launch multi-agent execution
  teammateCount?: number;     // ← How many teammates to spawn
}

export interface IUnifiedSwarmCoordinator {
  // Agent management
  registerAgent(agent: Omit<AgentState, 'id'>): Promise<string>;
  unregisterAgent(agentId: string): Promise<void>;
  getAgent(agentId: string): AgentState | undefined;
  getAllAgents(): AgentState[];
  // ...
}

requestJoin (13 refs) → Agent wants to join team
approveJoin (12 refs) → Coordinator approves
rejectJoin (11 refs) → Coordinator rejects
requestShutdown (14 refs) → Agent wants to leave
approveShutdown (9 refs) → Coordinator approves shutdown
rejectShutdown → Coordinator rejects (implicit)

CLAUDE_CODE_TMUX_SESSION       # tmux session name
CLAUDE_CODE_TMUX_PREFIX        # tmux prefix key
CLAUDE_CODE_TEAMMATE_COMMAND   # Spawn command

import { UnifiedSwarmCoordinator } from '@claude-flow/swarm';

const coordinator = new UnifiedSwarmCoordinator({
  topology: { type: 'hierarchical', maxAgents: 8 },
  consensus: { algorithm: 'raft', threshold: 0.66 },
});

await coordinator.initialize();

// Register agents
await coordinator.registerAgent({
  name: 'coder-1',
  type: 'coder',
  capabilities: { codeGeneration: true, languages: ['typescript'] }
});

// Via AgentInput to Task tool
Task({
  description: "Spawn coder",
  prompt: "You are a TypeScript coder...",
  subagent_type: "coder",
  name: "coder-1",
  team_name: "dev-team",
  allowed_tools: ["Edit", "Write", "Read"],
  mode: "default"
});

await coordinator.broadcastMessage({
  type: 'task_assign',
  payload: { taskId: 'task-123', description: 'Implement feature' }
}, 'high');

// Via TeammateTool.broadcast operation
TeammateTool.broadcast({
  from: 'coordinator',
  type: 'task',
  payload: { taskId: 'task-123', description: 'Implement feature' }
});

const proposal = await coordinator.proposeConsensus({
  plan: 'Implement authentication',
  steps: ['Create models', 'Add endpoints', 'Write tests']
});

// Agents vote
await consensusEngine.vote(proposal.id, {
  voterId: 'coder-1',
  approve: true,
  confidence: 0.9
});

const result = await consensusEngine.awaitConsensus(proposal.id);
if (result.approved) {
  // Execute plan
}

// Coordinator submits plan, teammates vote
// Then launch swarm with ExitPlanModeInput
ExitPlanMode({
  launchSwarm: true,
  teammateCount: 4,
  allowedPrompts: [
    { tool: 'Bash', prompt: 'Create models' },
    { tool: 'Bash', prompt: 'Add endpoints' },
    { tool: 'Bash', prompt: 'Write tests' }
  ]
});