"delegate" (17 refs)
"delegate_mode" (4 refs)
"delegate_mode_exit" (4 refs)
"delegateMode" (1 ref)

// NEED TO ADD
interface TeammateSpawnConfig {
  // ...existing fields...
  delegateAuthority?: boolean;       // Can this teammate delegate?
  delegatedPermissions?: string[];   // What can they approve?
  delegationDepth?: number;          // How many levels of delegation?
}

// NEED TO ADD
async delegateToTeammate(
  teamName: string,
  fromId: string,
  toId: string,
  permissions: string[]
): Promise<void>;

async revokeDelegation(
  teamName: string,
  fromId: string,
  toId: string
): Promise<void>;

"remote_agent" (11 refs)
"pushToRemote" (in ExitPlanModeInput)
"remoteSessionId" (in ExitPlanModeInput)
"remoteSessionUrl" (in ExitPlanModeInput)

// NEED TO ADD
interface RemoteSyncConfig {
  enabled: boolean;
  autoSync: boolean;
  syncInterval: number;  // ms
}

// NEED TO ADD
async pushTeamToRemote(teamName: string): Promise<{
  remoteSessionId: string;
  remoteSessionUrl: string;
}>;

async pullFromRemote(remoteSessionId: string): Promise<TeamState>;

async syncWithRemote(teamName: string): Promise<SyncResult>;

"session_memory" (8 refs)
"session_transcript" (5 refs)
"nested_memory" (4 refs)
"ultramemory" (3 refs)
"tengu_session_memory" (2 refs)

// NEED TO ADD
interface TeammateMemory {
  sessionId: string;
  teammateId: string;
  transcript: Message[];
  context: Record<string, unknown>;
  nestedMemories: TeammateMemory[];  // For hierarchical teams
}

// NEED TO ADD
async saveTeammateMemory(
  teamName: string,
  teammateId: string
): Promise<void>;

async loadTeammateMemory(
  teamName: string,
  teammateId: string
): Promise<TeammateMemory | null>;

async shareTranscript(
  teamName: string,
  fromId: string,
  toId: string,
  messageRange?: { start: number; end: number }
): Promise<void>;

"tengu_teleport_resume_session" (2 refs)
"tengu_teleport_resume_error" (3 refs)
"tengu_teleport_error_repo_not_in_git_dir_sessions_api" (1 ref)
"tengu_teleport_error_repo_mismatch_sessions_api" (1 ref)

// NEED TO ADD
interface TeleportConfig {
  autoResume: boolean;
  gitAware: boolean;
  preserveMailbox: boolean;
}

// NEED TO ADD
async teleportTeam(
  teamName: string,
  targetContext: {
    workingDirectory?: string;
    gitRepo?: string;
    sessionId?: string;
  }
): Promise<TeamState>;

async canTeleport(teamName: string): Promise<{
  canTeleport: boolean;
  blockers?: string[];
}>;

"team_context" (4 refs)
"team_permission_update" (3 refs)
"no_team_context" (1 ref)
"team_not_found" (3 refs)

// NEED TO ADD
interface TeamContext {
  teamName: string;
  sharedVariables: Record<string, unknown>;
  inheritedPermissions: string[];
  workingDirectory: string;
  gitBranch?: string;
  environmentVariables: Record<string, string>;
}

// NEED TO ADD
async updateTeamContext(
  teamName: string,
  updates: Partial<TeamContext>
): Promise<void>;

async updateTeammatePermissions(
  teamName: string,
  teammateId: string,
  permissions: {
    add?: string[];
    remove?: string[];
  }
): Promise<void>;

async getTeamContext(teamName: string): Promise<TeamContext>;

"plan_mode" (7 refs)
"plan_mode_exit" (6 refs)
"plan_mode_reentry" (4 refs)

// NEED TO ADD
async reenterPlanMode(
  teamName: string,
  planId: string,
  options?: {
    fromStep?: number;
    modifications?: PlanStep[];
  }
): Promise<TeamPlan>;

async pausePlanExecution(
  teamName: string,
  planId: string
): Promise<void>;

async resumePlanExecution(
  teamName: string,
  planId: string,
  fromStep?: number
): Promise<void>;

"worker_threads" (2 refs)
"workers" (1 ref)
"worker" (1 ref)
"worker_permission_prompt" (3 refs)

// NEED TO ADD (for advanced use cases)
interface WorkerConfig {
  maxWorkers: number;
  sharedMemory: boolean;
  taskQueue: 'fifo' | 'priority';
}

async spawnWorker(
  teamName: string,
  teammateId: string,
  task: WorkerTask
): Promise<string>;  // Returns worker ID

"swarm_teammate" (1 ref)

// NEED TO ADD
type TeammateType = 'regular' | 'swarm' | 'coordinator' | 'worker';

interface TeammateSpawnConfig {
  // ...existing fields...
  teammateType?: TeammateType;
}

"tmux" (26 refs)
CLAUDE_CODE_TMUX_SESSION
CLAUDE_CODE_TMUX_PREFIX

// NEED TO ADD
interface TmuxBackendConfig {
  sessionName?: string;
  windowName?: string;
  paneLayout?: 'tiled' | 'even-horizontal' | 'even-vertical';
  prefixKey?: string;
  shellCommand?: string;
  environment?: Record<string, string>;
}

async configureTmuxBackend(config: TmuxBackendConfig): Promise<void>;

async getTmuxPanes(sessionName: string): Promise<{
  paneId: string;
  teammateId: string;
  active: boolean;
}[]>;

async focusTmuxPane(sessionName: string, paneId: string): Promise<void>;

"in_process_teammate" (18 refs)
"InProcessTeammateTask" (1 ref)

// NEED TO ADD
interface InProcessConfig {
  maxConcurrent: number;
  memoryLimit: number;  // bytes
  timeoutMs: number;
  isolationLevel: 'none' | 'vm' | 'worker';
}

async getInProcessTeammates(): Promise<{
  teammateId: string;
  memoryUsage: number;
  cpuTime: number;
  status: string;
}[]>;

// NEED TO ADD to TeammateBridge
interface TeammateBridgeEvents {
  // Existing events...

  // Missing events:
  'delegate:granted': { team: string; from: string; to: string; permissions: string[] };
  'delegate:revoked': { team: string; from: string; to: string };
  'remote:pushed': { team: string; remoteUrl: string };
  'remote:synced': { team: string; changes: number };
  'memory:saved': { team: string; teammateId: string };
  'memory:loaded': { team: string; teammateId: string };
  'transcript:shared': { team: string; from: string; to: string };
  'context:updated': { team: string; keys: string[] };
  'permissions:updated': { team: string; teammateId: string };
  'plan:paused': { team: string; planId: string };
  'plan:resumed': { team: string; planId: string };
  'teleport:started': { team: string; target: object };
  'teleport:completed': { team: string; target: object };
  'worker:spawned': { team: string; teammateId: string; workerId: string };
  'worker:completed': { team: string; workerId: string; result: unknown };
}

// NEED TO ADD
class MemoryBridge {
  async syncTeammateMemoryToHNSW(
    teamName: string,
    teammateId: string
  ): Promise<void>;

  async queryTeammateContext(
    teamName: string,
    query: string,
    limit?: number
  ): Promise<ContextMatch[]>;

  async embedTeammateTranscript(
    teamName: string,
    teammateId: string
  ): Promise<void>;
}

// NEED TO ADD to Claude Flow hooks
const teammateHooks = {
  'teammate:pre-spawn': async (config: TeammateSpawnConfig) => { /* validate */ },
  'teammate:post-spawn': async (teammate: TeammateInfo) => { /* track */ },
  'teammate:pre-message': async (message: MailboxMessage) => { /* filter */ },
  'teammate:post-message': async (message: MailboxMessage) => { /* log */ },
  'teammate:plan-submitted': async (plan: TeamPlan) => { /* analyze */ },
  'teammate:plan-approved': async (plan: TeamPlan) => { /* notify */ },
};

// NEED TO ADD
class Consensusbridge {
  async mapTeammatePlanToConsensus(
    plan: TeamPlan
  ): Promise<ConsensusProposal>;

  async mapConsensusToTeammatePlan(
    proposal: ConsensusProposal
  ): Promise<TeamPlan>;

  async hybridConsensus(
    teamName: string,
    proposal: unknown,
    algorithm: 'native' | 'raft' | 'byzantine'
  ): Promise<ConsensusResult>;
}

// NEED TO ADD
class TeammateError extends Error {
  constructor(
    message: string,
    public code: TeammateErrorCode,
    public teamName?: string,
    public teammateId?: string
  ) {
    super(message);
  }
}

enum TeammateErrorCode {
  TEAM_NOT_FOUND = 'TEAM_NOT_FOUND',
  TEAMMATE_NOT_FOUND = 'TEAMMATE_NOT_FOUND',
  ALREADY_IN_TEAM = 'ALREADY_IN_TEAM',
  NO_TEAM_CONTEXT = 'NO_TEAM_CONTEXT',
  PLAN_NOT_APPROVED = 'PLAN_NOT_APPROVED',
  DELEGATION_DENIED = 'DELEGATION_DENIED',
  REMOTE_SYNC_FAILED = 'REMOTE_SYNC_FAILED',
  TELEPORT_FAILED = 'TELEPORT_FAILED',
  MAILBOX_FULL = 'MAILBOX_FULL',
  PERMISSION_DENIED = 'PERMISSION_DENIED',
  TIMEOUT = 'TIMEOUT',
}

// NEED TO ADD
interface RecoveryConfig {
  maxRetries: number;
  retryDelayMs: number;
  fallbackToMCP: boolean;
  autoCleanupOnError: boolean;
}

async recoverFromError(
  error: TeammateError,
  context: RecoveryContext
): Promise<RecoveryResult>;