macro-agent 0.1.4 → 0.1.6

package/dist/boot-v2-DMTHPQ4i.d.ts

@@ -0,0 +1,2672 @@
+import { PermissionMode, Session, AgentHandle, ExtendedSessionUpdate } from 'acp-factory';
+import { Stream, StartTaskResult, WorkerTask } from 'git-cascade';
+import Database from 'better-sqlite3';
+import { MessageContent, Importance, Message, AgentInbox } from 'agent-inbox';
+import { Express } from 'express';
+
+/**
+ * Primitive type definitions
+ */
+type AgentId$1 = string;
+type SessionId = string;
+type TaskId$1 = string;
+type EventId = string;
+type Timestamp = number;
+
+/**
+ * Agent-related type definitions
+ */
+
+type AgentState = "spawning" | "running" | "stopped" | "failed";
+type StopReason = "completed" | "failed" | "stopped" | "timeout" | "cancelled";
+interface AgentConfig$1 {
+    model?: string;
+    timeout?: number;
+    resource_limits?: {
+        max_tokens?: number;
+        max_children?: number;
+        [key: string]: unknown;
+    };
+}
+interface Agent {
+    id: AgentId$1;
+    /** Optional display name (set via rename, not derived from events) */
+    name?: string;
+    session_id: SessionId;
+    /** Session ID from the underlying agent provider (e.g., Claude Code UUID for --resume) */
+    provider_session_id?: string;
+    parent: AgentId$1 | null;
+    lineage: AgentId$1[];
+    state: AgentState;
+    stop_reason?: StopReason;
+    task: string;
+    task_id?: TaskId$1;
+    role?: string;
+    /** Team instance ID this agent belongs to (set by TeamManager) */
+    team_instance?: string;
+    config: AgentConfig$1;
+    cwd: string;
+    plan: Array<{
+        content: string;
+        priority: string;
+        status: string;
+    }>;
+    /** Arbitrary metadata (persisted out-of-band, not derived from events) */
+    metadata?: Record<string, unknown>;
+    created_at: Timestamp;
+    started_at?: Timestamp;
+    stopped_at?: Timestamp;
+    /** Last time this agent emitted an event (for health monitoring) */
+    last_activity_at?: Timestamp;
+}
+
+/**
+ * MergeQueue Types
+ *
+ * Types for the merge queue layer that coordinates parallel worker merges.
+ *
+ * @module workspace/merge-queue/types
+ * @implements [[s-bcqm]] Merge Queue Schema section
+ */
+/**
+ * Merge request status values.
+ *
+ * - pending: Waiting in queue to be processed
+ * - processing: Currently being merged by integrator
+ * - merged: Successfully merged into integration branch
+ * - conflict: Merge conflicts detected, needs resolution
+ * - abandoned: Worker abandoned, merge request cancelled
+ */
+type MergeRequestStatus = 'pending' | 'processing' | 'merged' | 'conflict' | 'abandoned';
+/**
+ * Merge request record.
+ *
+ * Represents a worker's completed work waiting to be merged
+ * into the integration branch.
+ */
+interface MergeRequest {
+    /** Unique identifier for the merge request */
+    id: string;
+    /** Stream (integration branch) this MR targets */
+    streamId: string;
+    /** Dataplane task ID this MR completes */
+    taskId: string;
+    /** Git branch containing the worker's changes */
+    workerBranch: string;
+    /** Agent ID of the worker that submitted this MR */
+    workerAgentId: string;
+    /** Current status of the merge request */
+    status: MergeRequestStatus;
+    /** Priority (lower = higher priority, default 100) */
+    priority: number;
+    /** Position in queue for manual reordering (null = auto) */
+    position: number | null;
+    /** Timestamp when MR was submitted */
+    submittedAt: number;
+    /** Timestamp when processing started */
+    startedAt: number | null;
+    /** Timestamp when merge completed (or conflict detected) */
+    completedAt: number | null;
+    /** Commit hash of the merge commit (when merged) */
+    mergeCommit: string | null;
+    /** Files with conflicts (when status = conflict) */
+    conflictFiles: string[] | null;
+    /** Task ID of resolver worker (when status = conflict) */
+    resolverTaskId: string | null;
+    /** Optional metadata */
+    metadata: Record<string, unknown>;
+}
+/**
+ * Options for submitting a merge request.
+ */
+interface SubmitMergeRequestOptions {
+    /** Stream (integration branch) to merge into */
+    streamId: string;
+    /** Dataplane task ID this completes */
+    taskId: string;
+    /** Git branch containing the worker's changes */
+    workerBranch: string;
+    /** Agent ID of the worker submitting */
+    workerAgentId: string;
+    /** Priority (default: 100) */
+    priority?: number;
+    /** Optional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Options for listing merge requests.
+ */
+interface ListMergeRequestsOptions {
+    /** Filter by status */
+    status?: MergeRequestStatus;
+    /** Limit number of results */
+    limit?: number;
+}
+/**
+ * MergeQueue event types.
+ */
+type MergeQueueEventType = 'mr:submitted' | 'mr:processing' | 'mr:merged' | 'mr:conflict' | 'mr:abandoned' | 'mr:resolved';
+/**
+ * MergeQueue event payload.
+ */
+interface MergeQueueEvent {
+    type: MergeQueueEventType;
+    timestamp: number;
+    data: Record<string, unknown>;
+}
+/**
+ * Callback for merge queue events.
+ */
+type MergeQueueEventCallback = (event: MergeQueueEvent) => void;
+/**
+ * MergeQueue interface.
+ *
+ * Coordinates merging of parallel worker branches into the integration branch.
+ * Workers submit completed work; Integrator processes sequentially.
+ */
+interface MergeQueueInterface {
+    /**
+     * Submit a merge request to the queue.
+     *
+     * @param options - Submit options
+     * @returns Merge request ID
+     */
+    submit(options: SubmitMergeRequestOptions): string;
+    /**
+     * Get the next pending merge request for a stream.
+     *
+     * Returns the highest priority (lowest number), oldest pending request.
+     *
+     * @param streamId - Stream ID
+     * @returns Next merge request or null if none pending
+     */
+    getNext(streamId: string): MergeRequest | null;
+    /**
+     * Mark a merge request as processing.
+     *
+     * @param mrId - Merge request ID
+     */
+    markProcessing(mrId: string): void;
+    /**
+     * Mark a merge request as successfully merged.
+     *
+     * @param mrId - Merge request ID
+     * @param mergeCommit - Commit hash of the merge commit
+     */
+    markMerged(mrId: string, mergeCommit: string): void;
+    /**
+     * Mark a merge request as having conflicts.
+     *
+     * @param mrId - Merge request ID
+     * @param conflictFiles - List of files with conflicts
+     * @param resolverTaskId - Optional task ID of resolver worker
+     */
+    markConflict(mrId: string, conflictFiles: string[], resolverTaskId?: string): void;
+    /**
+     * Mark a merge request as abandoned.
+     *
+     * @param mrId - Merge request ID
+     */
+    markAbandoned(mrId: string): void;
+    /**
+     * Mark a conflicted merge request as resolved and merged.
+     *
+     * Called after a resolver worker completes and the integrator
+     * performs an inline merge of the resolver's branch.
+     *
+     * @param mrId - Merge request ID (must be in 'conflict' status)
+     * @param mergeCommit - Commit hash from the resolver's inline merge
+     * @param resolverBranch - Branch the resolver worked on (for audit)
+     */
+    markResolverComplete(mrId: string, mergeCommit: string, resolverBranch?: string): void;
+    /**
+     * Get a merge request by ID.
+     *
+     * @param mrId - Merge request ID
+     * @returns Merge request or null if not found
+     */
+    get(mrId: string): MergeRequest | null;
+    /**
+     * Get pending merge requests for a stream.
+     *
+     * @param streamId - Stream ID
+     * @param options - List options
+     * @returns List of pending merge requests
+     */
+    getPending(streamId: string, options?: ListMergeRequestsOptions): MergeRequest[];
+    /**
+     * Get merge request by task ID.
+     *
+     * @param taskId - Task ID
+     * @returns Merge request or null if not found
+     */
+    getByTask(taskId: string): MergeRequest | null;
+    /**
+     * Get the number of pending merge requests for a stream.
+     *
+     * @param streamId - Stream ID
+     * @returns Queue depth
+     */
+    getQueueDepth(streamId: string): number;
+    /**
+     * Reposition a merge request in the queue.
+     *
+     * @param mrId - Merge request ID
+     * @param newPosition - New position (1-indexed)
+     */
+    reposition(mrId: string, newPosition: number): void;
+    /**
+     * Change the priority of a merge request.
+     *
+     * @param mrId - Merge request ID
+     * @param newPriority - New priority value
+     */
+    bumpPriority(mrId: string, newPriority: number): void;
+    /**
+     * Subscribe to merge queue events.
+     *
+     * @param callback - Event callback
+     * @returns Unsubscribe function
+     */
+    onEvent(callback: MergeQueueEventCallback): () => void;
+    /**
+     * Close the merge queue and release resources.
+     */
+    close(): void;
+}
+
+/**
+ * Workspace Types
+ *
+ * Types for workspace management, including Workspace, StreamConfig,
+ * and related interfaces for the WorkspaceManager.
+ *
+ * @module workspace/types
+ * @implements [[s-7ktd]] Workspace types section
+ */
+
+/**
+ * Agent identifier type
+ */
+type AgentId = string;
+/**
+ * Stream identifier type
+ */
+type StreamId = string;
+/**
+ * Task identifier type
+ */
+type TaskId = string;
+/**
+ * Agent role types that require workspaces
+ */
+type WorkspaceRole = 'worker' | 'integrator' | 'coordinator';
+/**
+ * Workspace represents an isolated git worktree assigned to an agent.
+ *
+ * @see [[s-7ktd]] Workspace by Role section
+ */
+interface Workspace {
+    /** Agent that owns this workspace */
+    agentId: AgentId;
+    /** Filesystem path to the worktree */
+    path: string;
+    /** Branch name in the worktree */
+    branch: string;
+    /** Stream (integration branch) this workspace belongs to */
+    streamId: StreamId;
+    /** Role of the agent using this workspace */
+    role: WorkspaceRole;
+    /** Timestamp when workspace was created */
+    createdAt: number;
+}
+/**
+ * Worker-specific workspace with task information.
+ *
+ * @see [[s-7ktd]] Worker Workspace section
+ */
+interface WorkerWorkspace extends Workspace {
+    role: 'worker';
+    /** Task assigned to this worker */
+    taskId: TaskId;
+    /** Base branch the worker branched from */
+    baseBranch: string;
+}
+/**
+ * Integrator-specific workspace for merge processing.
+ *
+ * @see [[s-7ktd]] Integrator Workspace section
+ */
+interface IntegratorWorkspace extends Workspace {
+    role: 'integrator';
+    /** Coordinator this integrator serves */
+    coordinatorId: AgentId;
+    /** Target integration branch for merges */
+    integrationBranch: string;
+}
+/**
+ * Coordinator-specific workspace on the integration branch.
+ *
+ * @see [[s-7ktd]] Coordinator Workspace section
+ */
+interface CoordinatorWorkspace extends Workspace {
+    role: 'coordinator';
+    /** Paths to child workspaces for visibility */
+    childWorkspacePaths: Map<AgentId, string>;
+}
+/**
+ * Configuration for creating an integration stream.
+ */
+interface StreamConfig {
+    /** Name for the stream (used in branch naming) */
+    name: string;
+    /** Branch to fork from (default: 'main') */
+    forkFrom?: string;
+    /** Optional metadata to attach to the stream */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Options for creating a task.
+ */
+interface CreateTaskOptions$1 {
+    /** Title/description of the task */
+    title: string;
+    /** Priority level (lower = higher priority) */
+    priority?: number;
+    /** Optional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * WorkspaceManager interface for managing agent workspaces.
+ *
+ * Bridges macro-agent roles to dataplane streams and worktrees.
+ *
+ * @see [[s-7ktd]] WorkspaceManager API section
+ */
+interface WorkspaceManager {
+    /**
+     * Create an integration stream for a coordinator.
+     *
+     * @param coordinatorId - ID of the coordinator agent
+     * @param config - Stream configuration
+     * @returns Stream ID
+     */
+    createIntegrationStream(coordinatorId: AgentId, config: StreamConfig): StreamId;
+    /**
+     * Get a stream by ID.
+     *
+     * @param streamId - Stream ID
+     * @returns Stream or null if not found
+     */
+    getStream(streamId: StreamId): Stream | null;
+    /**
+     * Create a workspace for a worker agent.
+     *
+     * @param workerId - ID of the worker agent
+     * @param taskId - ID of the task to work on
+     * @param streamId - ID of the integration stream
+     * @returns Worker workspace
+     */
+    createWorkerWorkspace(workerId: AgentId, taskId: TaskId, streamId: StreamId): WorkerWorkspace;
+    /**
+     * Create a workspace for an integrator agent.
+     *
+     * @param integratorId - ID of the integrator agent
+     * @param streamId - ID of the integration stream
+     * @returns Integrator workspace
+     */
+    createIntegratorWorkspace(integratorId: AgentId, streamId: StreamId): IntegratorWorkspace;
+    /**
+     * Create a workspace for a coordinator agent.
+     *
+     * @param coordinatorId - ID of the coordinator agent
+     * @param streamId - ID of the integration stream
+     * @returns Coordinator workspace
+     */
+    createCoordinatorWorkspace(coordinatorId: AgentId, streamId: StreamId): CoordinatorWorkspace;
+    /**
+     * Deallocate a workspace and release resources.
+     *
+     * @param agentId - ID of the agent whose workspace to deallocate
+     */
+    deallocateWorkspace(agentId: AgentId): void;
+    /**
+     * Create a task under a stream.
+     *
+     * @param streamId - ID of the integration stream
+     * @param options - Task creation options
+     * @returns Task ID
+     */
+    createTask(streamId: StreamId, options: CreateTaskOptions$1): TaskId;
+    /**
+     * Claim a task for a worker.
+     *
+     * @param taskId - ID of the task to claim
+     * @param workerId - ID of the worker agent
+     * @param worktree - Path to the worker's worktree
+     * @returns Start task result with branch info
+     */
+    claimTask(taskId: TaskId, workerId: AgentId, worktree: string): StartTaskResult;
+    /**
+     * Get the next available task for a stream.
+     *
+     * @param streamId - ID of the integration stream
+     * @returns Next task or null if none available
+     */
+    getNextTask(streamId: StreamId): WorkerTask | null;
+    /**
+     * Get workspace for an agent.
+     *
+     * @param agentId - ID of the agent
+     * @returns Workspace or null if not found
+     */
+    getWorkspace(agentId: AgentId): Workspace | null;
+    /**
+     * Get the stream ID for an agent.
+     *
+     * @param agentId - ID of the agent
+     * @returns Stream ID or null if not found
+     */
+    getStreamForAgent(agentId: AgentId): StreamId | null;
+    /**
+     * Register a child workspace path with a coordinator.
+     *
+     * @param coordinatorId - ID of the coordinator
+     * @param childId - ID of the child agent
+     * @param childPath - Filesystem path to child's workspace
+     */
+    registerChildWorkspace(coordinatorId: AgentId, childId: AgentId, childPath: string): void;
+    /**
+     * Get the merge queue for coordinating worker merges.
+     *
+     * The merge queue is shared across all streams and uses the same
+     * database as the dataplane adapter.
+     *
+     * @returns MergeQueue instance
+     */
+    getMergeQueue(): MergeQueueInterface;
+    /**
+     * Close the workspace manager and release resources.
+     */
+    close(): void;
+}
+
+/**
+ * AgentManager type definitions
+ */
+
+/**
+ * Options for spawning a new agent
+ */
+interface SpawnAgentOptions {
+    /** Task description for the agent */
+    task: string;
+    /** Optional task ID (auto-generated if not provided) */
+    task_id?: TaskId$1;
+    /** Parent agent ID (null for head managers) */
+    parent?: AgentId$1 | null;
+    /** Working directory for the agent */
+    cwd?: string;
+    /** Permission mode for tool calls */
+    permissionMode?: PermissionMode;
+    /** Whether parent should subscribe to this agent's subtree */
+    subscribeParent?: boolean;
+    /** Additional topics for the agent to subscribe to */
+    topics?: string[];
+    /** Custom configuration passed to agent */
+    config?: AgentConfig;
+    /** Optional agent type (defaults to "claude-code") */
+    agentType?: string;
+    /**
+     * Custom prompt content injected as the role instructions section.
+     * When set, replaces resolvedRole.systemPrompt in prompt assembly.
+     * Used by team templates to provide static role prompts.
+     */
+    customPrompt?: string;
+    /**
+     * Interaction pattern sections to append after the role prompt.
+     * Auto-generated by TeamRuntime based on team config (pull mode, etc.).
+     */
+    interactionPatterns?: string[];
+    /**
+     * Agent role name (e.g., 'worker', 'coordinator', 'integrator', 'monitor').
+     * If not provided, role is inferred from parent presence.
+     */
+    role?: string;
+    /** Team instance ID this agent belongs to (set by TeamManager interceptor) */
+    team_instance?: string;
+    /**
+     * Stream ID to join (for workers and integrators).
+     * Required for workers and integrators when using workspace isolation.
+     */
+    streamId?: StreamId;
+    /**
+     * Stream configuration for creating a new integration stream.
+     * Used by coordinators to create their integration branch.
+     */
+    streamConfig?: StreamConfig;
+    /**
+     * Dataplane task ID to claim (for workers).
+     * If provided, the worker will claim this task and work on it.
+     */
+    dataplaneTaskId?: string;
+    /**
+     * Resolved capabilities for this agent's role.
+     * Injected by TeamRuntime spawn interceptor for capability-based workspace dispatch.
+     */
+    capabilities?: string[];
+}
+/**
+ * Options for continuing a terminated agent
+ */
+interface ContinueAgentOptions {
+    /** Maximum number of conversation turns to include in context (default: 50) */
+    maxMessages?: number;
+    /** Override the task description for the continuation */
+    task?: string;
+    /** Additional context to prepend to the continuation prompt */
+    additionalContext?: string;
+}
+/**
+ * Custom agent configuration
+ */
+interface AgentConfig {
+    /** Model to use (if configurable) */
+    model?: string;
+    /** Maximum tokens per response */
+    maxTokens?: number;
+    /** Temperature for responses */
+    temperature?: number;
+    /** Additional environment variables */
+    env?: Record<string, string>;
+    /** MCP servers to connect */
+    mcpServers?: MCPServerConfig[];
+}
+/**
+ * MCP server configuration
+ */
+interface MCPServerConfig {
+    name: string;
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+}
+/**
+ * Result of spawning an agent
+ */
+interface SpawnedAgent {
+    /** Agent ID */
+    id: AgentId$1;
+    /** Session ID from acp-factory */
+    session_id: string;
+    /** Agent state from materialized view */
+    agent: Agent;
+    /** Active session for interaction */
+    session: Session;
+    /** Workspace assigned to the agent (if any) */
+    workspace?: Workspace;
+    /** Stream ID the agent belongs to (if any) */
+    streamId?: StreamId;
+}
+/**
+ * Filter options for listing agents
+ */
+interface AgentFilter {
+    /** Filter by state */
+    state?: AgentState;
+    /** Filter by parent */
+    parent?: AgentId$1 | null;
+    /** Filter by task ID */
+    task_id?: TaskId$1;
+    /** Only head managers (no parent) */
+    headManagersOnly?: boolean;
+}
+/**
+ * Agent hierarchy node
+ */
+interface AgentHierarchyNode {
+    agent: Agent;
+    children: AgentHierarchyNode[];
+}
+/**
+ * Full agent hierarchy from root
+ */
+interface AgentHierarchy {
+    root: AgentHierarchyNode;
+    depth: number;
+    totalAgents: number;
+}
+/**
+ * Options for getHierarchy
+ */
+interface HierarchyOptions {
+    /** Maximum depth to traverse (undefined = full tree) */
+    depth?: number;
+}
+/**
+ * Active session info tracked in memory
+ */
+interface ActiveSession {
+    /** Agent ID */
+    agentId: AgentId$1;
+    /** acp-factory agent handle (process) */
+    handle: AgentHandle;
+    /** acp-factory session */
+    session: Session;
+    /** When the session was created */
+    createdAt: Timestamp;
+    /** Whether session is currently prompting */
+    isPrompting: boolean;
+}
+/**
+ * Stop reason for agent termination
+ * Named AgentStopReason to avoid conflict with ACP SDK's StopReason
+ */
+type AgentStopReason = "completed" | "failed" | "cancelled" | "timeout" | "parent_stopped" | "system";
+/**
+ * Options for creating a head manager
+ */
+interface HeadManagerOptions {
+    /** Working directory */
+    cwd: string;
+    /** Optional custom system prompt */
+    systemPrompt?: string;
+    /** Permission mode */
+    permissionMode?: PermissionMode;
+    /** Initial topics to subscribe to */
+    topics?: string[];
+    /** Resume a specific session by ID */
+    sessionId?: string;
+    /** Force creation of a new session, ignoring existing ones */
+    forceNew?: boolean;
+}
+/**
+ * Context for generating system prompts
+ */
+interface SystemPromptContext {
+    /** Agent ID */
+    agentId: AgentId$1;
+    /** Task description */
+    task: string;
+    /** Task ID if assigned */
+    taskId?: TaskId$1;
+    /** Parent agent ID */
+    parentId?: AgentId$1 | null;
+    /** Whether this is a head manager */
+    isHeadManager: boolean;
+    /** Agent lineage (ancestors) */
+    lineage: AgentId$1[];
+    /** Available MCP tools */
+    mcpTools?: string[];
+    /** Agent role name (e.g., 'worker', 'coordinator') */
+    role?: string;
+    /** Workspace assigned to the agent */
+    workspace?: Workspace;
+    /** Stream ID the agent belongs to */
+    streamId?: StreamId;
+}
+/**
+ * Agent lifecycle events (for callbacks)
+ */
+type AgentLifecycleEvent = {
+    type: "spawned";
+    agent: Agent;
+} | {
+    type: "started";
+    agent: Agent;
+} | {
+    type: "stopped";
+    agent: Agent;
+    reason: AgentStopReason;
+} | {
+    type: "status";
+    agent: Agent;
+    status: string;
+};
+/**
+ * Callback for agent lifecycle events
+ */
+type AgentLifecycleCallback = (event: AgentLifecycleEvent) => void;
+/**
+ * Agent manager error
+ */
+declare class AgentManagerError extends Error {
+    readonly code: AgentManagerErrorCode;
+    readonly agentId?: AgentId$1 | undefined;
+    constructor(message: string, code: AgentManagerErrorCode, agentId?: AgentId$1 | undefined);
+}
+type AgentManagerErrorCode = "AGENT_NOT_FOUND" | "SESSION_NOT_FOUND" | "SPAWN_FAILED" | "ALREADY_RUNNING" | "NOT_RUNNING" | "INVALID_STATE" | "PERMISSION_DENIED" | "CAPABILITY_DENIED" | "SHUTDOWN_IN_PROGRESS" | "FORK_NOT_SUPPORTED";
+
+/**
+ * Role System Type Definitions
+ *
+ * Implements the composable role system from s-60tc:
+ * - Capability-based permissions
+ * - Enforcement mechanisms (workspace, tools, lifecycle, protocol, permissions)
+ * - Role definition and registry interfaces
+ */
+/** File operation capabilities */
+type FileCapability = "file.read" | "file.write" | "file.delete";
+/** Git operation capabilities */
+type GitCapability = "git.commit" | "git.merge" | "git.push" | "git.branch.create" | "git.branch.delete";
+/** Agent management capabilities */
+type AgentCapability = "agent.spawn.worker" | "agent.spawn.integrator" | "agent.spawn.monitor" | "agent.spawn.custom" | "agent.terminate";
+/** Lifecycle capabilities */
+type LifecycleCapability = "lifecycle.done" | "lifecycle.persistent" | "lifecycle.daemon";
+/** Task management capabilities (via TaskBackend, see s-8472) */
+type TaskCapability = "task.create" | "task.assign" | "task.update" | "task.close" | "task.claim";
+/** Execution capabilities */
+type ExecCapability = "exec.command" | "exec.build" | "exec.test" | "exec.lint";
+/** Communication capabilities */
+type MsgCapability = "msg.send" | "msg.broadcast" | "msg.subscribe";
+/** Workspace capabilities */
+type WorkspaceCapability = "workspace.worktree" | "workspace.stream" | "workspace.integrate";
+/** All capability types combined, plus wildcard */
+type Capability = FileCapability | GitCapability | AgentCapability | LifecycleCapability | TaskCapability | ExecCapability | MsgCapability | WorkspaceCapability | "*";
+/**
+ * Workspace Enforcement
+ * Controls filesystem access and isolation.
+ */
+interface WorkspaceEnforcement {
+    /** Workspace type */
+    type: "own" | "shared" | "mount" | "none";
+    /** For 'own' type: branch naming pattern */
+    branchPattern?: string;
+    /** For 'own' type: cleanup workspace on agent termination */
+    cleanupOnTerminate?: boolean;
+    /** For 'own' type: can read child workspace paths (Coordinator) */
+    canViewChildWorkspaces?: boolean;
+    /** For 'shared' type: role names to share with */
+    sharedWith?: string[];
+    /** For 'mount' type: branch/path to mount */
+    mountTarget?: string;
+    /** For 'mount' type: read-only access */
+    readonly?: boolean;
+}
+/**
+ * Tool Enforcement
+ * Controls which MCP tools are available.
+ */
+interface ToolEnforcement {
+    /** Mode for tool filtering */
+    mode: "capability" | "allowlist" | "denylist" | "all";
+    /** For allowlist/denylist modes: explicit tool names */
+    tools?: string[];
+}
+/**
+ * Lifecycle Enforcement
+ * Controls agent lifecycle behavior.
+ */
+interface LifecycleEnforcement {
+    /** Lifecycle type */
+    type: "ephemeral" | "persistent" | "daemon" | "event-driven";
+    /** For ephemeral: terminate when task completes */
+    taskBound?: boolean;
+    /** For ephemeral: timeout in milliseconds (default: 30 min for workers) */
+    maxDurationMs?: number;
+    /** For event-driven: terminate when parent terminates */
+    parentBound?: boolean;
+    /** For all types: terminate children on done */
+    cascadeTerminate?: boolean;
+    /** For all types: clean own workspace on done */
+    selfCleanup?: boolean;
+}
+/**
+ * Protocol Enforcement
+ * Controls message routing and subscriptions.
+ */
+interface ProtocolEnforcement {
+    /** Message patterns to receive */
+    subscriptions: string[];
+    /** Message patterns allowed to send */
+    canEmit: string[];
+}
+/**
+ * Capability restriction for fine-grained control
+ */
+interface CapabilityRestriction {
+    /** Scope restriction (e.g., "own-workspace" vs "any") */
+    scope?: string;
+    /** Rate limit (max calls per minute) */
+    rateLimit?: number;
+    /** Requires human approval */
+    requireApproval?: boolean;
+}
+/**
+ * Permission Enforcement
+ * Controls capability-level permissions with optional restrictions.
+ */
+interface PermissionEnforcement {
+    /** List of capability IDs */
+    capabilities: Capability[];
+    /** Optional restrictions on capabilities */
+    restrictions?: Record<string, CapabilityRestriction>;
+}
+/**
+ * Role Definition
+ * Combines capabilities with enforcement mechanisms.
+ */
+interface RoleDefinition {
+    /** Unique role identifier (supports dot-notation like 'worker.resolver') */
+    name: string;
+    /** Human-readable name */
+    displayName?: string;
+    /** Role purpose description */
+    description?: string;
+    /** List of capability IDs */
+    capabilities: Capability[];
+    /** Workspace enforcement configuration */
+    workspace?: WorkspaceEnforcement;
+    /** Tool enforcement configuration */
+    tools?: ToolEnforcement;
+    /** Lifecycle enforcement configuration */
+    lifecycle?: LifecycleEnforcement;
+    /** Protocol enforcement configuration */
+    protocol?: ProtocolEnforcement;
+    /** Permission enforcement configuration */
+    permissions?: PermissionEnforcement;
+    /** Inherit from another role */
+    extends?: string;
+    /** Role-specific system prompt */
+    systemPrompt?: string;
+    /** Path to prompt template file */
+    promptTemplate?: string;
+}
+/**
+ * Role Configuration
+ * Extends RoleDefinition with override behavior for configuration files.
+ */
+interface RoleConfig extends RoleDefinition {
+    /** Override behavior (only for roles matching built-in names) */
+    override?: "replace" | "merge";
+}
+/**
+ * Role Registry Interface
+ * Manages role definitions with layered resolution.
+ */
+interface RoleRegistry {
+    /** Get a role by name (exact match, no inheritance) */
+    getRole(name: string): RoleDefinition | undefined;
+    /** Register a role definition */
+    registerRole(role: RoleDefinition): void;
+    /** List all registered roles */
+    listRoles(): RoleDefinition[];
+    /** Resolve a role with inheritance and fallback */
+    resolveRole(name: string): RoleDefinition;
+    /** Check if a role has a specific capability */
+    hasCapability(roleName: string, capability: Capability): boolean;
+}
+
+/**
+ * AgentStore — Minimal SQLite store for agent lifecycle and session state.
+ *
+ * Replaces the heavy EventStore + TinyBase materialized views with
+ * simple CRUD on two tables: agents and sessions.
+ *
+ * @module agent/agent-store
+ */
+
+/**
+ * Agent record stored in SQLite. Minimal lifecycle state only —
+ * messages live in agent-inbox, tasks live in opentasks.
+ */
+interface AgentRecord {
+    id: AgentId$1;
+    name?: string;
+    role: string;
+    state: AgentState;
+    stop_reason?: StopReason;
+    parent_id: AgentId$1 | null;
+    lineage: AgentId$1[];
+    team?: string;
+    scope: string;
+    task: string;
+    task_id?: string;
+    cwd: string;
+    capabilities: string[];
+    workspace_path?: string;
+    workspace_stream_id?: string;
+    config?: Record<string, unknown>;
+    metadata?: Record<string, unknown>;
+    created_at: Timestamp;
+    started_at?: Timestamp;
+    stopped_at?: Timestamp;
+    last_activity_at?: Timestamp;
+}
+/**
+ * Session record mapping agent IDs to acp-factory sessions.
+ */
+interface SessionRecord {
+    agent_id: AgentId$1;
+    session_id: SessionId;
+    provider_session_id?: string;
+    created_at: Timestamp;
+}
+/**
+ * Filter options for listing agents.
+ */
+interface AgentStoreFilter {
+    state?: AgentState;
+    role?: string;
+    team?: string;
+    parent_id?: AgentId$1 | null;
+    scope?: string;
+}
+type ChangeCallback = (event: {
+    type: "put" | "update" | "remove";
+    agentId: string;
+}) => void;
+declare class AgentStore {
+    private db;
+    private changeListeners;
+    constructor(dbPath?: string);
+    /**
+     * Subscribe to agent store changes. Returns an unsubscribe function.
+     */
+    onChange(callback: ChangeCallback): () => void;
+    private notifyChange;
+    putAgent(agent: AgentRecord): void;
+    getAgent(id: AgentId$1): AgentRecord | null;
+    listAgents(filter?: AgentStoreFilter): AgentRecord[];
+    updateAgent(id: AgentId$1, updates: Partial<AgentRecord>): void;
+    removeAgent(id: AgentId$1): void;
+    getChildren(parentId: AgentId$1): AgentRecord[];
+    getDescendants(agentId: AgentId$1): AgentRecord[];
+    getAncestors(agentId: AgentId$1): AgentRecord[];
+    putSession(session: SessionRecord): void;
+    getSession(agentId: AgentId$1): SessionRecord | null;
+    removeSession(agentId: AgentId$1): void;
+    close(): void;
+    /** Get the underlying database (for advanced use / testing). */
+    get database(): Database.Database;
+    private rowToAgent;
+}
+
+/**
+ * Adapter interfaces for subsystem integration.
+ *
+ * InboxAdapter wraps agent-inbox for messaging.
+ * TasksAdapter wraps opentasks for task management.
+ *
+ * These are the only two touch points between macro-agent
+ * and the external subsystems.
+ *
+ * @module adapters/types
+ */
+
+/**
+ * Event emitted when a message is delivered to an agent's inbox.
+ */
+interface InboxDeliveryEvent {
+    /** Recipient agent ID */
+    agentId: string;
+    /** Recipient kind (to, cc, bcc) */
+    recipientKind: "to" | "cc" | "bcc";
+    /** The delivered message */
+    message: Message;
+}
+/**
+ * Signal filter: returns false to suppress delivery to a specific agent.
+ * Used by TeamRuntime to enforce subscription-based signal filtering.
+ */
+type SignalFilterFn = (from: string, to: string, message: Message) => boolean;
+/**
+ * Emission validator: returns a rejection reason string to block the send,
+ * or null to allow it. Used by TeamRuntime to enforce per-role emission rules.
+ */
+type EmissionValidatorFn = (from: string, message: Message) => string | null;
+/**
+ * Options for registering an agent with agent-inbox.
+ */
+interface RegisterAgentOptions {
+    name?: string;
+    role: string;
+    scope: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Options for sending a message through agent-inbox.
+ */
+interface SendMessageOptions {
+    threadTag?: string;
+    importance?: Importance;
+    scope?: string;
+    subject?: string;
+    inReplyTo?: string;
+}
+/**
+ * Delivery event handler callback.
+ */
+type DeliveryHandler = (event: InboxDeliveryEvent) => void;
+/**
+ * InboxAdapter — macro-agent's interface to agent-inbox.
+ *
+ * Owns adapter-side signal filtering and emission validation.
+ * Embeds agent-inbox in-process for zero-latency event access,
+ * with IPC server running for agent MCP subprocesses.
+ */
+interface InboxAdapter {
+    /** Register an agent in agent-inbox's storage and warm registry. */
+    registerAgent(agentId: string, opts: RegisterAgentOptions): Promise<void>;
+    /** Deregister an agent (set status to offline). */
+    deregisterAgent(agentId: string): Promise<void>;
+    /**
+     * Send a message. Emission validation runs before forwarding
+     * to agent-inbox. Returns the message ID on success.
+     *
+     * @throws if emission validator rejects the send.
+     */
+    send(from: string, to: string | string[], content: MessageContent | string, opts?: SendMessageOptions): Promise<string>;
+    /**
+     * Subscribe to delivery events. Signal filtering runs before
+     * invoking the handler — filtered messages are silently dropped.
+     */
+    onDelivery(handler: DeliveryHandler): void;
+    /** Remove a delivery handler. */
+    offDelivery(handler: DeliveryHandler): void;
+    /** Check an agent's inbox. */
+    checkInbox(agentId: string, opts?: {
+        unreadOnly?: boolean;
+        limit?: number;
+    }): Promise<Message[]>;
+    /** Read a message thread by tag. */
+    readThread(threadTag: string, scope?: string): Promise<Message[]>;
+    /** Install a signal filter (replaces any existing filter). */
+    setSignalFilter(filter: SignalFilterFn): void;
+    /** Install an emission validator (replaces any existing validator). */
+    setEmissionValidator(validator: EmissionValidatorFn): void;
+    /** Add a named signal filter (for multi-team). */
+    addSignalFilter(id: string, filter: SignalFilterFn): void;
+    /** Remove a named signal filter. */
+    removeSignalFilter(id: string): void;
+    /** Add a named emission validator (for multi-team). */
+    addEmissionValidator(id: string, validator: EmissionValidatorFn): void;
+    /** Remove a named emission validator. */
+    removeEmissionValidator(id: string): void;
+    /** The IPC socket path for agent subprocesses to connect to. */
+    readonly socketPath: string;
+    /** Stop the embedded agent-inbox (IPC server, storage, etc.). */
+    stop(): Promise<void>;
+}
+/**
+ * Task status values used by macro-agent.
+ * Maps to opentasks canonical statuses.
+ */
+type TaskStatus = "open" | "in_progress" | "blocked" | "closed";
+/**
+ * Semantic actions for task state transitions.
+ */
+type TaskAction = "start" | "complete" | "fail" | "block" | "reopen";
+/**
+ * Options for creating a task.
+ */
+interface CreateTaskOptions {
+    title: string;
+    content?: string;
+    assignee?: string;
+    parent?: string;
+    tags?: string[];
+    priority?: number;
+}
+/**
+ * Options for querying tasks.
+ */
+interface TaskQueryOptions {
+    status?: TaskStatus;
+    assignee?: string;
+    tags?: string[];
+    limit?: number;
+}
+/**
+ * Simplified task record returned by the adapter.
+ * Flattened from opentasks' graph node model.
+ */
+interface TaskRecord {
+    id: string;
+    title: string;
+    content?: string;
+    status: TaskStatus;
+    assignee?: string;
+    parent?: string;
+    tags?: string[];
+    priority?: number;
+    claimed_by?: string;
+    created_at?: string;
+    closed_at?: string;
+    metadata?: Record<string, unknown>;
+}
+/**
+ * TasksAdapter — macro-agent's interface to opentasks.
+ *
+ * Wraps OpenTasksClient via IPC to the opentasks daemon.
+ * macro-agent ensures the daemon is running at boot.
+ */
+interface TasksAdapter {
+    /** Create a new task. Returns the task ID. */
+    createTask(opts: CreateTaskOptions): Promise<string>;
+    /** Assign a task to an agent. */
+    assignTask(taskId: string, agentId: string): Promise<void>;
+    /** Transition a task to a new state via semantic action. */
+    transitionTask(taskId: string, action: TaskAction): Promise<void>;
+    /** Get a single task by ID. */
+    getTask(taskId: string): Promise<TaskRecord>;
+    /** Query tasks ready to work on (no active blockers). */
+    queryReady(opts?: {
+        tags?: string[];
+        limit?: number;
+    }): Promise<TaskRecord[]>;
+    /** List tasks with optional filters. */
+    listTasks(filter?: TaskQueryOptions): Promise<TaskRecord[]>;
+    /** Add a blocking dependency: blockerId blocks taskId. */
+    addBlocker(taskId: string, blockerId: string): Promise<void>;
+    /** Remove a blocking dependency. */
+    removeBlocker(taskId: string, blockerId: string): Promise<void>;
+    /** Claim the next available task matching the filter. */
+    claimTask(agentId: string, filter?: {
+        tags?: string[];
+    }): Promise<TaskRecord | null>;
+    /** Release a claimed task back to the pool. */
+    unclaimTask(taskId: string): Promise<void>;
+    /** List tasks available for claiming. */
+    listClaimable(filter?: {
+        tags?: string[];
+        limit?: number;
+    }): Promise<TaskRecord[]>;
+    /** Connect to the opentasks daemon. Auto-starts if needed. */
+    connect(): Promise<void>;
+    /** Disconnect from the opentasks daemon. */
+    disconnect(): void;
+    /** Whether the adapter is connected to the daemon. */
+    readonly connected: boolean;
+}
+
+/**
+ * AgentManager - Interface and types for managing agent lifecycle and sessions
+ *
+ * The V1 implementation has been removed. The V2 implementation lives in
+ * agent-manager-v2.ts and is wired via boot-v2.ts.
+ *
+ * This file retains:
+ * - The AgentManager interface (used everywhere)
+ * - The AgentManagerConfig interface
+ * - The SpawnInterceptor type
+ * - A re-export of createAgentManagerV2 as createAgentManager for backward compat
+ */
+
+interface AgentManager {
+    /**
+     * Spawn a new agent with the given options.
+     * Creates the acp-factory session and emits spawn event.
+     */
+    spawn(options: SpawnAgentOptions): Promise<SpawnedAgent>;
+    /**
+     * Terminate an agent and clean up its session.
+     * Emits terminate event and updates task status if assigned.
+     */
+    terminate(agentId: AgentId$1, reason: AgentStopReason): Promise<void>;
+    /**
+     * Resume a stopped agent by loading its existing session.
+     * @param permissionMode - Optional permission mode override (defaults to the agent manager's default)
+     */
+    resume(agentId: AgentId$1, permissionMode?: PermissionMode): Promise<SpawnedAgent>;
+    /**
+     * Continue a terminated agent by spawning a new agent with the same
+     * role and task, injecting the prior conversation context as a
+     * resume prefix in the system prompt.
+     *
+     * @param agentId - ID of the agent to continue
+     * @param options - Continuation options
+     * @returns The newly spawned continuation agent
+     */
+    continueAgent(agentId: AgentId$1, options?: ContinueAgentOptions): Promise<SpawnedAgent>;
+    /**
+     * Fork an agent's session, creating a new agent with the same
+     * conversation history. Uses forkWithFlush for active sessions
+     * or loadSession for stopped agents with persisted sessions.
+     *
+     * @param sourceAgentId - ID of the agent to fork from
+     * @param options - Fork options (name, prompt, cwd)
+     */
+    forkAgent(sourceAgentId: AgentId$1, options?: {
+        name?: string;
+        prompt?: string;
+        cwd?: string;
+    }): Promise<SpawnedAgent>;
+    /**
+     * Get agent by ID from materialized view.
+     */
+    get(agentId: AgentId$1): Agent | null;
+    /**
+     * List agents with optional filters.
+     */
+    list(filter?: AgentFilter): Agent[];
+    /**
+     * Get direct children of an agent.
+     */
+    getChildren(agentId: AgentId$1): Agent[];
+    /**
+     * Get full hierarchy tree starting from an agent.
+     * @param options.depth - Maximum depth to traverse (undefined = full tree)
+     */
+    getHierarchy(agentId: AgentId$1, options?: HierarchyOptions): AgentHierarchy | null;
+    /**
+     * Get or create a head manager for the given workspace.
+     * Head managers are root agents with no parent.
+     */
+    getOrCreateHeadManager(options: HeadManagerOptions): Promise<SpawnedAgent>;
+    /**
+     * List all head managers.
+     */
+    listHeadManagers(): Agent[];
+    /**
+     * Send a prompt to an agent and stream responses.
+     */
+    prompt(agentId: AgentId$1, message: string): AsyncIterable<ExtendedSessionUpdate>;
+    /**
+     * Send a prompt to an agent and automatically follow up to ensure done() is called.
+     * Returns when the agent calls done() or after maxFollowUps attempts.
+     *
+     * @param agentId - Agent ID to prompt
+     * @param message - Initial prompt message
+     * @param options - Follow-up options
+     * @returns Result indicating whether done() was called
+     */
+    promptUntilDone(agentId: AgentId$1, message: string, options?: {
+        /** Maximum number of follow-up prompts (default: 2) */
+        maxFollowUps?: number;
+        /** Callback for each update during prompting */
+        onUpdate?: (update: ExtendedSessionUpdate) => void;
+    }): Promise<{
+        doneCalled: boolean;
+        doneStatus?: string;
+        updates: ExtendedSessionUpdate[];
+    }>;
+    /**
+     * Get the active session for an agent.
+     */
+    getSession(agentId: AgentId$1): Session | null;
+    /**
+     * Check if an agent has an active session.
+     */
+    hasActiveSession(agentId: AgentId$1): boolean;
+    /**
+     * Check if an agent is currently processing a prompt.
+     * Returns false if no session or session is idle.
+     */
+    isPrompting(agentId: AgentId$1): boolean;
+    /**
+     * Check if an agent's session supports context injection.
+     * Returns false if no session or injection not supported.
+     */
+    supportsInjection(agentId: AgentId$1): Promise<boolean>;
+    /**
+     * Check if an agent's underlying process is still running.
+     * Returns false if no session or process has exited.
+     */
+    isProcessRunning(agentId: AgentId$1): boolean;
+    /**
+     * Respond to a permission request for an agent's session.
+     * Used when running in interactive permission mode.
+     *
+     * @param agentId - Agent ID whose session has the pending permission
+     * @param requestId - The permission request ID
+     * @param optionId - The selected option ID (e.g., 'allow_once')
+     * @returns true if permission was found and responded to
+     */
+    respondToPermission(agentId: AgentId$1, requestId: string, optionId: string): boolean;
+    /**
+     * Cancel a permission request for an agent's session.
+     *
+     * @param agentId - Agent ID whose session has the pending permission
+     * @param requestId - The permission request ID
+     * @returns true if permission was found and cancelled
+     */
+    cancelPermission(agentId: AgentId$1, requestId: string): boolean;
+    /**
+     * Change the permission mode for a running agent at runtime.
+     * Takes effect on the next permission request.
+     *
+     * @param agentId - Agent ID to change permission mode for
+     * @param mode - New permission mode
+     * @returns true if the mode was changed successfully
+     */
+    setPermissionMode(agentId: AgentId$1, mode: PermissionMode): boolean;
+    /**
+     * Get the current permission mode for a running agent.
+     *
+     * @param agentId - Agent ID to query
+     * @returns The current permission mode, or null if no active session
+     */
+    getPermissionMode(agentId: AgentId$1): PermissionMode | null;
+    /**
+     * Register a callback for agent lifecycle events.
+     */
+    onLifecycleEvent(callback: AgentLifecycleCallback): () => void;
+    /**
+     * Set a spawn interceptor that transforms SpawnAgentOptions before spawning.
+     * Used by TeamRuntime to inject team topics, prompts, MCP servers, and env vars.
+     */
+    setSpawnInterceptor(interceptor: SpawnInterceptor | null): void;
+    /**
+     * Get the RoleRegistry used by this AgentManager.
+     */
+    getRoleRegistry(): RoleRegistry;
+    /**
+     * Set the runtime OpenTasks socket path for propagation to child agents.
+     * Used when createTaskBackend() discovers the daemon socket path after
+     * AgentManager is already created.
+     */
+    setOpenTasksSocketPath(socketPath: string): void;
+    /**
+     * Set the MAP server URL for propagation to child agents via SWARM_MAP_SERVER.
+     * When set, spawned agents with cc-swarm hooks will connect to macro-agent's
+     * local MAP server instead of directly to an external hub.
+     */
+    setMapServerUrl(url: string): void;
+    /**
+     * Configure swarmkit integrations (minimem, skill-tree, sessionlog).
+     * Called by boot-v2 after system initialization.
+     */
+    setIntegrationConfigs(configs: {
+        minimem?: {
+            enabled: boolean;
+            dir?: string;
+            provider?: string;
+            global?: boolean;
+        };
+        skilltree?: {
+            enabled: boolean;
+            basePath?: string;
+            defaultProfile?: string;
+        };
+        sessionlog?: {
+            enabled: boolean;
+            sync?: string;
+        };
+    }): void;
+    /**
+     * Set a compiled skill-tree loadout for a role.
+     * Called by TeamRuntime during team bootstrap.
+     */
+    setSkillLoadout(role: string, content: string): void;
+    /**
+     * Set the MAP sidecar reference for trajectory reporting.
+     * Called by boot-v2 after the sidecar is created.
+     * Enables session-end checkpoint emission on terminate.
+     */
+    setSidecar(sidecar: {
+        connected: boolean;
+        reportCheckpoint(cp: any): Promise<any>;
+    } | null): void;
+    /**
+     * Close all active sessions and clean up resources.
+     */
+    close(): Promise<void>;
+}
+interface AgentManagerConfig {
+    /** Default permission mode for spawned agents */
+    defaultPermissionMode?: PermissionMode;
+    /** Default agent type (defaults to "claude-code") */
+    defaultAgentType?: string;
+    /** Default working directory */
+    defaultCwd?: string;
+    /**
+     * Optional WorkspaceManager for workspace isolation.
+     * When provided, agents with workspace-enabled roles will get
+     * isolated git worktrees.
+     */
+    workspaceManager?: WorkspaceManager;
+    /**
+     * Optional RoleRegistry for capability enforcement.
+     * When provided, spawn operations will check if the parent agent
+     * has the required capability to spawn the requested child role.
+     * Defaults to DefaultRoleRegistry if not provided.
+     */
+    roleRegistry?: RoleRegistry;
+    /**
+     * Optional server URL for MCP thin-client mode.
+     * When set, spawned agents use ephemeral MAP WebSocket calls instead
+     * of creating local service stacks.
+     */
+    serverUrl?: string;
+    /**
+     * Server authentication token for MCP thin-client connections.
+     * Passed to spawned agents as MACRO_SERVER_TOKEN env var.
+     */
+    serverToken?: string;
+    /**
+     * OpenTasks socket path to propagate to child MCP subprocesses.
+     * Sourced from merged config. Falls back to OPENTASKS_SOCKET_PATH env var.
+     */
+    openTasksSocketPath?: string;
+}
+/**
+ * Function that transforms SpawnAgentOptions before an agent is spawned.
+ * Used by TeamRuntime to inject team-specific configuration.
+ */
+type SpawnInterceptor = (options: SpawnAgentOptions) => SpawnAgentOptions | Promise<SpawnAgentOptions>;
+
+/**
+ * MAP Sidecar Types
+ *
+ * Configuration, interfaces, and wire format types for the MAP hub sidecar.
+ * The sidecar connects macro-agent to an OpenHive MAP hub for agent observability,
+ * trajectory reporting, task bridging, and cross-swarm coordination.
+ *
+ * @module map/types
+ */
+
+interface MAPSidecarConfig {
+    /** MAP hub WebSocket URL (e.g., "ws://localhost:8080" or "wss://hub.openhive.dev") */
+    server: string;
+    /** Authentication token (appended as ?token= query param) */
+    token?: string;
+    /** MAP scope for broadcasting events (default: "swarm:macro-agent") */
+    scope?: string;
+    /** System ID for federation (default: "macro-agent") */
+    systemId?: string;
+    /** Opaque credential for server-driven auth (verified mode) */
+    credential?: string;
+    /** Agent name for MAP registration (default: "macro-agent-sidecar") */
+    agentName?: string;
+    /** Trajectory sync level */
+    trajectorySyncLevel?: "off" | "lifecycle" | "metrics" | "full";
+    /** Mesh transport (agentic-mesh P2P) */
+    mesh?: {
+        enabled?: boolean;
+        peerId?: string;
+    };
+    /** Reconnection settings (SDK-level) */
+    reconnection?: {
+        enabled?: boolean;
+        maxRetries?: number;
+        baseDelayMs?: number;
+        maxDelayMs?: number;
+    };
+    /** Slow reconnect interval after SDK retries exhausted (ms, default: 60000) */
+    reconnectIntervalMs?: number;
+}
+interface MAPSidecarDeps {
+    agentManager: AgentManager;
+    agentStore: AgentStore;
+    inboxAdapter: InboxAdapter;
+    tasksAdapter: TasksAdapter;
+}
+interface MAPSidecar {
+    /** Start the sidecar (connect to hub, subscribe to events) */
+    start(): Promise<void>;
+    /** Stop the sidecar (disconnect, unsubscribe) */
+    stop(): Promise<void>;
+    /** Whether the sidecar is connected to the hub */
+    readonly connected: boolean;
+    /** Report a trajectory checkpoint manually */
+    reportCheckpoint(checkpoint: TrajectoryCheckpointPayload): Promise<TrajectoryCheckpointResult | null>;
+}
+/**
+ * Trajectory checkpoint payload — matches cc-swarm wire format.
+ * Top-level fields are snake_case per the OpenHive trajectory protocol.
+ */
+interface TrajectoryCheckpointPayload {
+    /** Checkpoint ID (e.g., "<sessionId>-step<N>") */
+    id: string;
+    /** Session identifier */
+    session_id: string;
+    /** Agent name (e.g., "macro-agent-sidecar") */
+    agent: string;
+    /** Git branch (nullable) */
+    branch: string | null;
+    /** Files touched in this checkpoint period */
+    files_touched: string[];
+    /** Total checkpoint count in session */
+    checkpoints_count: number;
+    /** Token usage metrics (when sync level >= "metrics") */
+    token_usage?: {
+        input_tokens?: number;
+        output_tokens?: number;
+        cache_creation_tokens?: number;
+        cache_read_tokens?: number;
+        api_call_count?: number;
+    };
+    /** Additional metadata */
+    metadata?: {
+        project?: string;
+        projectPath?: string;
+        template?: string;
+        firstPrompt?: string;
+        phase?: string;
+        [key: string]: unknown;
+    };
+}
+/** Response from trajectory/checkpoint extension call */
+interface TrajectoryCheckpointResult {
+    ok: boolean;
+    resource_id?: string;
+    created?: boolean;
+    checkpoint_id?: string;
+}
+/** Configuration for the MAP server that accepts inbound connections */
+interface MapServerConfig {
+    /** Port for MAP WebSocket server (default: 3002) */
+    port?: number;
+    /** Host to bind (default: "127.0.0.1") */
+    host?: string;
+    /** WebSocket path (default: "/map") */
+    path?: string;
+    /** Server name for MAP protocol (default: "macro-agent") */
+    name?: string;
+}
+/** MAP server instance for accepting inbound MAP connections */
+interface MAPServerInstance {
+    /** Start the server */
+    start(): Promise<void>;
+    /** Stop the server */
+    stop(): Promise<void>;
+    /** Get the WebSocket URL */
+    getUrl(): string;
+    /** Get number of active connections */
+    getConnectionCount(): number;
+}
+
+/**
+ * InboxAdapter — Wraps agent-inbox for macro-agent's messaging needs.
+ *
+ * Embeds agent-inbox in-process (hybrid model):
+ * - macro-agent gets zero-latency event access via inbox.events
+ * - Agent MCP subprocesses connect via IPC socket
+ *
+ * Owns adapter-side policy enforcement:
+ * - Signal filtering (before delivery to handler)
+ * - Emission validation (before forwarding to inbox)
+ *
+ * @module adapters/inbox-adapter
+ */
+
+interface InboxAdapterConfig {
+    /** Path to SQLite database for inbox persistence. */
+    sqlitePath?: string;
+    /** IPC socket path for agent subprocesses. */
+    socketPath: string;
+    /** Default scope for standalone agents (default: "default"). */
+    defaultScope?: string;
+    /** Federation config for cross-instance communication. */
+    federation?: {
+        systemId?: string;
+        peers?: Array<{
+            systemId: string;
+            url?: string;
+            meshPeerId?: string;
+        }>;
+        trust?: {
+            allowedServers?: string[];
+        };
+    };
+}
+declare class DefaultInboxAdapter implements InboxAdapter {
+    private inbox;
+    private handlers;
+    private signalFilters;
+    private emissionValidators;
+    private readonly config;
+    private readonly defaultScope;
+    constructor(config: InboxAdapterConfig);
+    /**
+     * Initialize the embedded agent-inbox instance.
+     * Must be called before any other methods.
+     */
+    initialize(): Promise<void>;
+    get socketPath(): string;
+    registerAgent(agentId: string, opts: RegisterAgentOptions): Promise<void>;
+    deregisterAgent(agentId: string): Promise<void>;
+    send(from: string, to: string | string[], content: MessageContent | string, opts?: SendMessageOptions): Promise<string>;
+    onDelivery(handler: DeliveryHandler): void;
+    offDelivery(handler: DeliveryHandler): void;
+    checkInbox(agentId: string, opts?: {
+        unreadOnly?: boolean;
+        limit?: number;
+    }): Promise<Message[]>;
+    readThread(threadTag: string, scope?: string): Promise<Message[]>;
+    setSignalFilter(filter: SignalFilterFn): void;
+    setEmissionValidator(validator: EmissionValidatorFn): void;
+    addSignalFilter(id: string, filter: SignalFilterFn): void;
+    removeSignalFilter(id: string): void;
+    addEmissionValidator(id: string, validator: EmissionValidatorFn): void;
+    removeEmissionValidator(id: string): void;
+    stop(): Promise<void>;
+    /** Get the underlying AgentInbox instance (for advanced use). */
+    getInbox(): AgentInbox;
+    private requireInbox;
+    private handleDeliveryEvent;
+}
+
+/**
+ * TasksAdapter — Wraps opentasks client for macro-agent's task management.
+ *
+ * Connects to the opentasks daemon via IPC. Uses autoConnect to
+ * auto-start the daemon if it's not running.
+ *
+ * Translates between macro-agent's domain types and opentasks'
+ * graph model (nodes, edges, semantic actions).
+ *
+ * @module adapters/tasks-adapter
+ */
+
+interface TasksAdapterConfig {
+    /** Path to opentasks daemon socket (auto-discovered if not set). */
+    socketPath?: string;
+    /** Request timeout in milliseconds (default: 30000). */
+    timeout?: number;
+}
+declare class DefaultTasksAdapter implements TasksAdapter {
+    private client;
+    private readonly config;
+    private _connected;
+    constructor(config?: TasksAdapterConfig);
+    get connected(): boolean;
+    connect(): Promise<void>;
+    disconnect(): void;
+    createTask(opts: CreateTaskOptions): Promise<string>;
+    assignTask(taskId: string, agentId: string): Promise<void>;
+    transitionTask(taskId: string, action: TaskAction): Promise<void>;
+    getTask(taskId: string): Promise<TaskRecord>;
+    queryReady(opts?: {
+        tags?: string[];
+        limit?: number;
+    }): Promise<TaskRecord[]>;
+    listTasks(filter?: TaskQueryOptions): Promise<TaskRecord[]>;
+    addBlocker(taskId: string, blockerId: string): Promise<void>;
+    removeBlocker(taskId: string, blockerId: string): Promise<void>;
+    claimTask(agentId: string, filter?: {
+        tags?: string[];
+    }): Promise<TaskRecord | null>;
+    unclaimTask(taskId: string): Promise<void>;
+    listClaimable(filter?: {
+        tags?: string[];
+        limit?: number;
+    }): Promise<TaskRecord[]>;
+    private requireClient;
+    private nodeToTaskRecord;
+}
+
+/**
+ * Control Socket Server
+ *
+ * NDJSON over UNIX socket. Exposes AgentManager lifecycle operations
+ * to MCP subprocesses. Runs in the main macro-agent process.
+ *
+ * Protocol: One JSON object per line. Request → Response.
+ * Same pattern as agent-inbox's IPC server.
+ *
+ * @module control/control-server
+ */
+
+interface ControlServerConfig {
+    socketPath: string;
+}
+interface AgentHealthStatus {
+    healthy: boolean;
+    lastSeen: number;
+    pid: number;
+}
+declare class ControlServer {
+    private server;
+    private readonly socketPath;
+    private readonly agentManager;
+    private readonly heartbeats;
+    private readonly connections;
+    constructor(agentManager: AgentManager, config: ControlServerConfig);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private handleConnection;
+    private handleLine;
+    private handleSpawn;
+    private handleTerminate;
+    private handleGetAgent;
+    private handleListAgents;
+    private handleGetChildren;
+    private handleGetHierarchy;
+    private handleHealthCheck;
+    getHealthStatus(agentId: string): AgentHealthStatus | null;
+    getUnhealthyAgents(timeoutMs: number): Array<{
+        agentId: string;
+        lastSeen: number;
+        pid: number;
+    }>;
+}
+
+/**
+ * Core Trigger System Types
+ *
+ * Defines the foundational types for the trigger system including
+ * trigger events, sources, payloads, and delivery results.
+ *
+ * @module trigger/types
+ */
+
+/**
+ * Sources that can generate trigger events
+ */
+type TriggerSource = {
+    type: "cron";
+    jobId: string;
+    jobName: string;
+} | {
+    type: "webhook";
+    endpointId: string;
+    method: string;
+    path: string;
+} | {
+    type: "system";
+    eventType: string;
+} | {
+    type: "channel";
+    channelType: string;
+    channelId: string;
+} | {
+    type: "internal";
+    component: string;
+};
+/**
+ * Payload variants for trigger events
+ */
+type TriggerPayload = {
+    kind: "text";
+    content: string;
+} | {
+    kind: "json";
+    data: Record<string, unknown>;
+} | {
+    kind: "activity";
+    activityType: string;
+    details?: Record<string, unknown>;
+};
+/**
+ * Wake mode determines how the trigger is delivered to the agent
+ *
+ * - "now": Immediately wake the agent using inject/interrupt chain
+ * - "next-prompt": Queue the event to be delivered on agent's next prompt
+ */
+type TriggerWakeMode = "now" | "next-prompt";
+/**
+ * Target specification for trigger routing
+ */
+type TriggerTarget = {
+    type: "head";
+} | {
+    type: "agent";
+    agentId: AgentId$1;
+} | {
+    type: "role";
+    role: string;
+} | {
+    type: "task";
+    taskId: TaskId$1;
+} | {
+    type: "broadcast";
+    channel: string;
+} | {
+    type: "ai-router";
+};
+/**
+ * Routing hints for trigger delivery
+ */
+interface TriggerRoutingHint {
+    /** Primary target specification */
+    target?: TriggerTarget;
+    /** Fallback target if primary fails */
+    fallbackTarget?: TriggerTarget;
+    /** Custom routing strategy name */
+    strategyName?: string;
+    /** Whether to spawn new agent if target not found */
+    spawnIfNotFound?: boolean;
+    /** Spawn configuration if spawning is allowed */
+    spawnConfig?: {
+        task: string;
+        role?: string;
+        parentId?: AgentId$1;
+    };
+}
+/**
+ * Priority levels for trigger events
+ */
+type TriggerPriority = "low" | "normal" | "high" | "urgent";
+/**
+ * A trigger event to be routed to agents
+ */
+interface TriggerEvent {
+    /** Unique event ID */
+    id: string;
+    /** Source of the trigger */
+    source: TriggerSource;
+    /** Payload content */
+    payload: TriggerPayload;
+    /** Wake mode for delivery */
+    wakeMode: TriggerWakeMode;
+    /** Event creation timestamp */
+    timestamp: number;
+    /** Routing configuration */
+    routing?: TriggerRoutingHint;
+    /** Priority level */
+    priority?: TriggerPriority;
+    /** Optional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Method used to deliver the trigger
+ */
+type TriggerDeliveryMethod = "queued" | "inject" | "interrupt" | "wake" | "spawn" | "broadcast";
+/**
+ * Result of trigger delivery attempt
+ */
+interface TriggerDeliveryResult {
+    /** Whether delivery succeeded */
+    success: boolean;
+    /** Agent(s) that received the trigger */
+    deliveredTo: AgentId$1[];
+    /** Delivery method used */
+    method: TriggerDeliveryMethod;
+    /** Whether a new agent was spawned */
+    spawned?: boolean;
+    /** ID of spawned agent if applicable */
+    spawnedAgentId?: AgentId$1;
+    /** Error message if failed */
+    error?: string;
+    /** Additional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Minimal TriggerRouter interface for routing trigger events.
+ * The full V1 router module was removed in the V2 cutover.
+ */
+interface TriggerRouter {
+    /** Route a trigger event to target agents */
+    route(event: TriggerEvent): Promise<TriggerDeliveryResult>;
+}
+
+/**
+ * System Event Queue Types
+ *
+ * Types for the per-agent ephemeral event queue that stores
+ * pending system events to be delivered on the next prompt.
+ *
+ * @module trigger/queue/types
+ */
+
+/**
+ * A system event queued for an agent
+ */
+interface QueuedSystemEvent {
+    /** Event text/content */
+    text: string;
+    /** Timestamp when queued */
+    ts: number;
+    /** Source identifier for deduplication */
+    sourceKey?: string;
+    /** Priority for ordering */
+    priority?: "low" | "normal" | "high" | "urgent";
+}
+/**
+ * Options for enqueueing a system event
+ */
+interface EnqueueOptions {
+    /** Target agent ID */
+    agentId: AgentId$1;
+    /** Optional context key for change detection */
+    contextKey?: string | null;
+    /** Optional source key for deduplication */
+    sourceKey?: string;
+    /** Priority level */
+    priority?: "low" | "normal" | "high" | "urgent";
+}
+/**
+ * Options for draining the queue
+ */
+interface DrainOptions {
+    /** Whether to include priority in sorting */
+    sortByPriority?: boolean;
+    /** Maximum number of events to drain */
+    limit?: number;
+}
+/**
+ * System event queue interface
+ *
+ * Manages per-agent ephemeral event queues. Events are queued
+ * and drained into the agent's next prompt.
+ */
+interface SystemEventQueue {
+    /**
+     * Enqueue an event for an agent
+     * @param text - Event text content
+     * @param options - Enqueue options including agent ID
+     */
+    enqueue(text: string, options: EnqueueOptions): void;
+    /**
+     * Drain all events for an agent (returns and clears queue)
+     * @param agentId - Target agent ID
+     * @param options - Optional drain options
+     * @returns Array of queued events
+     */
+    drain(agentId: AgentId$1, options?: DrainOptions): QueuedSystemEvent[];
+    /**
+     * Drain events as text strings only
+     * @param agentId - Target agent ID
+     * @param options - Optional drain options
+     * @returns Array of event text strings
+     */
+    drainText(agentId: AgentId$1, options?: DrainOptions): string[];
+    /**
+     * Peek at queued events without removing them
+     * @param agentId - Target agent ID
+     * @returns Array of event text strings
+     */
+    peek(agentId: AgentId$1): string[];
+    /**
+     * Check if agent has queued events
+     * @param agentId - Target agent ID
+     * @returns True if events are queued
+     */
+    hasEvents(agentId: AgentId$1): boolean;
+    /**
+     * Get count of queued events for an agent
+     * @param agentId - Target agent ID
+     * @returns Number of queued events
+     */
+    getEventCount(agentId: AgentId$1): number;
+    /**
+     * Check if context has changed since last enqueue
+     * @param agentId - Target agent ID
+     * @param contextKey - Context key to check
+     * @returns True if context has changed
+     */
+    isContextChanged(agentId: AgentId$1, contextKey?: string | null): boolean;
+    /**
+     * Clear queue for a specific agent
+     * @param agentId - Target agent ID
+     */
+    clear(agentId: AgentId$1): void;
+    /**
+     * Clear all queues (for testing/reset)
+     */
+    reset(): void;
+    /**
+     * Get all agent IDs with pending events
+     * @returns Array of agent IDs
+     */
+    getAgentsWithEvents(): AgentId$1[];
+}
+
+/**
+ * Trigger Wake System Types
+ *
+ * Types for the wake manager that handles polling agents
+ * with pending events and delivering them.
+ *
+ * ## Wake System Architecture
+ *
+ * There are two wake mechanisms in macro-agent:
+ *
+ * 1. **Single-Agent Wake** (agent/wake.ts, activity/types.ts)
+ *    - For immediately waking a single agent with an Activity
+ *    - Priority-driven (urgent/high/normal/low)
+ *    - Uses inject/interrupt fallback chain
+ *    - Returns `WakeResult` (success: boolean, method: WakeMethod)
+ *
+ * 2. **Batch Wake Cycles** (trigger/wake/*)
+ *    - For periodic delivery of queued system events
+ *    - Heartbeat-based polling with coalescing
+ *    - Processes all agents with pending events
+ *    - Returns `WakeCycleStatus` (status: ran/skipped/failed)
+ *
+ * Use single-agent wake for: Immediate message delivery, activity notifications
+ * Use batch wake cycles for: Scheduled event delivery, system-wide polling
+ *
+ * @module trigger/wake/types
+ */
+
+/**
+ * Wake request for immediate agent activation
+ */
+interface WakeRequest {
+    /** Reason for the wake request */
+    reason: string;
+    /** Source component requesting wake */
+    source?: string;
+    /** Optional specific agent to wake */
+    agentId?: AgentId$1;
+    /** Coalesce delay in ms (default: 250) */
+    coalesceMs?: number;
+}
+/**
+ * Status of a batch wake cycle.
+ *
+ * Note: This is different from `WakeResult` in activity/types.ts which
+ * represents the outcome of waking a single agent.
+ */
+interface WakeCycleStatus {
+    status: "ran" | "skipped" | "failed";
+    /** Duration if ran */
+    durationMs?: number;
+    /** Reason if skipped or failed */
+    reason?: string;
+    /** Agents that were woken */
+    wokenAgents?: AgentId$1[];
+}
+/**
+ * Wake manager interface
+ */
+interface TriggerWakeManager {
+    /**
+     * Request an immediate wake cycle
+     * @param request - Wake request details
+     */
+    requestWakeNow(request?: WakeRequest): void;
+    /**
+     * Check if a wake is pending
+     * @returns True if wake is scheduled
+     */
+    hasPendingWake(): boolean;
+    /**
+     * Run a single wake cycle immediately
+     * @param opts - Optional reason for the cycle
+     * @returns Wake cycle status
+     */
+    runWakeCycle(opts?: {
+        reason?: string;
+    }): Promise<WakeCycleStatus>;
+    /**
+     * Start the wake manager (enables heartbeat if configured)
+     */
+    start(): void;
+    /**
+     * Stop the wake manager
+     */
+    stop(): void;
+    /**
+     * Check if manager is running
+     */
+    isRunning(): boolean;
+    /**
+     * Get pending wake reason if any
+     */
+    getPendingReason(): string | null;
+}
+
+/**
+ * Cron Service Types
+ *
+ * Types for the cron scheduler that manages time-based triggers.
+ *
+ * @module trigger/sources/cron/types
+ */
+
+/**
+ * One-shot schedule - runs once at a specific time
+ */
+interface AtSchedule {
+    kind: "at";
+    /** Unix timestamp in milliseconds */
+    atMs: number;
+}
+/**
+ * Recurring interval schedule
+ */
+interface EverySchedule {
+    kind: "every";
+    /** Interval in milliseconds */
+    everyMs: number;
+    /** Optional anchor time for alignment */
+    anchorMs?: number;
+}
+/**
+ * Cron expression schedule
+ */
+interface CronExprSchedule {
+    kind: "cron";
+    /** Cron expression (5 or 6 fields) */
+    expr: string;
+    /** Timezone (IANA format, e.g., "America/New_York") */
+    tz?: string;
+}
+/**
+ * Union of all schedule types
+ */
+type CronSchedule = AtSchedule | EverySchedule | CronExprSchedule;
+/**
+ * System event payload - injects text into agent's context
+ */
+interface SystemEventPayload {
+    kind: "systemEvent";
+    /** Text to inject as system event */
+    text: string;
+}
+/**
+ * Agent prompt payload - sends a full prompt to agent
+ */
+interface AgentPromptPayload {
+    kind: "agentPrompt";
+    /** Message to send to agent */
+    message: string;
+    /** Optional timeout in seconds */
+    timeoutSeconds?: number;
+    /** Optional model override */
+    model?: string;
+}
+/**
+ * Union of job payload types
+ */
+type CronJobPayload = SystemEventPayload | AgentPromptPayload;
+/**
+ * Job execution state
+ */
+interface CronJobState {
+    /** Next scheduled run time */
+    nextRunAtMs?: number;
+    /** Currently running since (undefined if not running) */
+    runningAtMs?: number;
+    /** Last run time */
+    lastRunAtMs?: number;
+    /** Last run status */
+    lastStatus?: "ok" | "error" | "skipped";
+    /** Last error message if failed */
+    lastError?: string;
+    /** Last run duration in ms */
+    lastDurationMs?: number;
+    /** Run count */
+    runCount?: number;
+}
+/**
+ * Session target for job execution
+ */
+type CronSessionTarget = "main" | "isolated";
+/**
+ * Full cron job definition
+ */
+interface CronJob {
+    /** Unique job ID */
+    id: string;
+    /** Human-readable name */
+    name: string;
+    /** Optional description */
+    description?: string;
+    /** Whether job is enabled */
+    enabled: boolean;
+    /** Delete job after successful run (for one-shot jobs) */
+    deleteAfterRun?: boolean;
+    /** Creation timestamp */
+    createdAtMs: number;
+    /** Last update timestamp */
+    updatedAtMs: number;
+    /** Schedule specification */
+    schedule: CronSchedule;
+    /** Session target */
+    sessionTarget: CronSessionTarget;
+    /** Wake mode for trigger delivery */
+    wakeMode: TriggerWakeMode;
+    /** Job payload */
+    payload: CronJobPayload;
+    /** Optional routing hints */
+    routing?: TriggerRoutingHint;
+    /** Optional target agent ID (overrides routing) */
+    targetAgentId?: AgentId$1;
+    /** Job state */
+    state: CronJobState;
+    /** Optional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Input for creating a cron job
+ */
+type CronJobCreate = Omit<CronJob, "id" | "createdAtMs" | "updatedAtMs" | "state"> & {
+    /** Optional initial state */
+    state?: Partial<CronJobState>;
+};
+/**
+ * Input for updating a cron job
+ */
+type CronJobPatch = Partial<Omit<CronJob, "id" | "createdAtMs" | "state">> & {
+    /** Partial state update */
+    state?: Partial<CronJobState>;
+};
+/**
+ * Filter options for listing jobs
+ */
+interface CronJobFilter {
+    /** Include disabled jobs */
+    includeDisabled?: boolean;
+    /** Filter by name pattern */
+    namePattern?: string;
+    /** Filter by session target */
+    sessionTarget?: CronSessionTarget;
+}
+/**
+ * Cron service interface
+ */
+interface CronService {
+    /**
+     * Start the cron service
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the cron service
+     */
+    stop(): Promise<void>;
+    /**
+     * Check if service is running
+     */
+    isRunning(): boolean;
+    /**
+     * List all jobs
+     */
+    list(filter?: CronJobFilter): Promise<CronJob[]>;
+    /**
+     * Get a job by ID
+     */
+    get(id: string): Promise<CronJob | null>;
+    /**
+     * Add a new job
+     */
+    add(input: CronJobCreate): Promise<CronJob>;
+    /**
+     * Update an existing job
+     */
+    update(id: string, patch: CronJobPatch): Promise<CronJob>;
+    /**
+     * Remove a job
+     */
+    remove(id: string): Promise<void>;
+    /**
+     * Enable a job
+     */
+    enable(id: string): Promise<CronJob>;
+    /**
+     * Disable a job
+     */
+    disable(id: string): Promise<CronJob>;
+    /**
+     * Manually run a job
+     */
+    run(id: string, opts?: {
+        force?: boolean;
+    }): Promise<void>;
+    /**
+     * Trigger a job immediately (alias for run with force: true)
+     */
+    triggerNow(id: string): Promise<void>;
+    /**
+     * Get next scheduled run time across all jobs
+     */
+    getNextRunTime(): number | null;
+}
+
+/**
+ * Webhook Types
+ *
+ * Types for the webhook trigger source that handles
+ * incoming HTTP requests.
+ *
+ * @module trigger/sources/webhook/types
+ */
+
+/**
+ * HTTP methods supported for webhooks
+ */
+type WebhookMethod = "POST" | "PUT" | "PATCH" | "GET" | "DELETE";
+/**
+ * Webhook endpoint configuration
+ */
+interface WebhookEndpoint {
+    /** Unique endpoint ID */
+    id: string;
+    /** Human-readable name */
+    name: string;
+    /** Optional description */
+    description?: string;
+    /** Allowed HTTP methods */
+    methods: WebhookMethod[];
+    /** Path pattern (e.g., "/hooks/github") */
+    path: string;
+    /** Whether endpoint is enabled */
+    enabled: boolean;
+    /** Secret for signature validation */
+    secret?: string;
+    /** Wake mode for triggers */
+    wakeMode: TriggerWakeMode;
+    /** Default routing hints */
+    routing?: TriggerRoutingHint;
+    /** Creation timestamp */
+    createdAtMs: number;
+    /** Last update timestamp */
+    updatedAtMs: number;
+    /** Optional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Input for creating a webhook endpoint
+ */
+type WebhookEndpointCreate = Omit<WebhookEndpoint, "id" | "createdAtMs" | "updatedAtMs">;
+/**
+ * Input for updating a webhook endpoint
+ */
+type WebhookEndpointPatch = Partial<Omit<WebhookEndpoint, "id" | "createdAtMs">>;
+/**
+ * Parsed webhook request
+ */
+interface WebhookRequest {
+    /** Endpoint that matched */
+    endpointId: string;
+    /** HTTP method */
+    method: WebhookMethod;
+    /** Request path */
+    path: string;
+    /** Query parameters */
+    query: Record<string, string | string[]>;
+    /** Request headers */
+    headers: Record<string, string | string[] | undefined>;
+    /** Request body (parsed JSON or raw string) */
+    body: unknown;
+    /** Raw body for signature validation */
+    rawBody?: string;
+    /** Timestamp of request */
+    timestamp: number;
+    /** Client IP address */
+    clientIp?: string;
+}
+/**
+ * Webhook handler interface
+ */
+interface WebhookHandler {
+    /**
+     * List all registered endpoints
+     */
+    listEndpoints(): Promise<WebhookEndpoint[]>;
+    /**
+     * Get an endpoint by ID
+     */
+    getEndpoint(id: string): Promise<WebhookEndpoint | null>;
+    /**
+     * Register a new endpoint
+     */
+    registerEndpoint(input: WebhookEndpointCreate): Promise<WebhookEndpoint>;
+    /**
+     * Update an endpoint
+     */
+    updateEndpoint(id: string, patch: WebhookEndpointPatch): Promise<WebhookEndpoint>;
+    /**
+     * Remove an endpoint
+     */
+    removeEndpoint(id: string): Promise<void>;
+    /**
+     * Handle an incoming webhook request
+     */
+    handleRequest(request: WebhookRequest): Promise<WebhookHandleResult>;
+    /**
+     * Validate a webhook signature
+     */
+    validateSignature(endpointId: string, signature: string, body: string): Promise<boolean>;
+}
+/**
+ * Result of handling a webhook request
+ */
+interface WebhookHandleResult {
+    success: boolean;
+    /** Trigger ID if created */
+    triggerId?: string;
+    /** Error message if failed */
+    error?: string;
+    /** HTTP status code to return */
+    statusCode: number;
+    /** Response body */
+    responseBody?: unknown;
+}
+
+/**
+ * Trigger System V2 Factory
+ *
+ * Rewired to use InboxAdapter instead of EventStore/MessageRouter.
+ * Connects inbox delivery events to WakeManager for agent wake decisions.
+ *
+ * Key changes from V1:
+ * - InboxAdapter.onDelivery → WakeManager delivery chain
+ * - RoutingContext uses AgentStore instead of EventStore
+ * - RoutingContext uses InboxAdapter instead of MessageRouter
+ * - WakeManager unchanged (only depends on AgentManager interface)
+ * - SystemEventQueue unchanged (no external deps)
+ * - CronService/WebhookHandler unchanged (only depend on router + wake)
+ *
+ * @module trigger/trigger-system-v2
+ */
+
+interface TriggerSystemV2 {
+    readonly queue: SystemEventQueue;
+    readonly router: TriggerRouterV2;
+    readonly wakeManager: TriggerWakeManager;
+    readonly cronService: CronService;
+    readonly webhookHandler: WebhookHandler;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    isRunning(): boolean;
+}
+/**
+ * Context provided to routing strategies for making decisions.
+ * V2 version uses AgentStore + InboxAdapter instead of EventStore + MessageRouter.
+ */
+interface RoutingContext {
+    agentStore: AgentStore;
+    agentManager: AgentManager;
+    inboxAdapter: InboxAdapter;
+    systemEventQueue: SystemEventQueue;
+}
+/**
+ * Routing decision returned by a strategy.
+ */
+interface RoutingDecision {
+    targetAgents: string[];
+    spawnNew?: {
+        task: string;
+        role?: string;
+        parentId?: string;
+    };
+    additionalContext?: string;
+    wakeModeOverride?: "now" | "next-prompt";
+    reason?: string;
+    defer?: boolean;
+    deferReason?: string;
+}
+/**
+ * Pluggable routing strategy interface.
+ * Implement this to create custom routing strategies for trigger delivery.
+ */
+interface RoutingStrategy {
+    readonly name: string;
+    readonly description?: string;
+    /** Determine routing for a trigger event. */
+    route(event: TriggerEvent, context: RoutingContext): Promise<RoutingDecision>;
+    /** Check if this strategy can handle the event (optional). */
+    canHandle?(event: TriggerEvent): boolean;
+    /** Initialize the strategy (optional). */
+    initialize?(context: RoutingContext): Promise<void>;
+    /** Cleanup the strategy (optional). */
+    cleanup?(): Promise<void>;
+}
+/**
+ * V2 Trigger Router with pluggable strategy support.
+ */
+interface TriggerRouterV2 extends TriggerRouter {
+    registerStrategy(strategy: RoutingStrategy): void;
+    unregisterStrategy(name: string): void;
+    getStrategy(name: string): RoutingStrategy | undefined;
+    listStrategies(): string[];
+    setDefaultStrategy(name: string): void;
+    getDefaultStrategy(): string;
+}
+
+/**
+ * REST API request/response types.
+ *
+ * @module api/types
+ */
+
+interface ApiServer {
+    /** Express application instance */
+    app: Express;
+    /** Start listening */
+    start(): Promise<void>;
+    /** Stop the server */
+    stop(): Promise<void>;
+}
+
+/**
+ * WebSocket ACP Server — Multi-client WebSocket transport for the ACP protocol.
+ *
+ * Accepts WebSocket connections, creates a bidirectional Stream for each,
+ * and wires up an AgentSideConnection with the macro-agent ACP handler.
+ *
+ * Also provides a /health HTTP endpoint.
+ *
+ * @module acp/websocket-server
+ */
+
+interface WebSocketACPServer {
+    /** Start listening for connections */
+    start(): Promise<void>;
+    /** Stop the server and close all connections */
+    stop(): Promise<void>;
+    /** Number of active WebSocket connections */
+    getConnectionCount(): number;
+    /** The URL the server is listening on */
+    getUrl(): string;
+}
+
+interface BootV2Config {
+    /** Working directory (default: process.cwd()) */
+    cwd?: string;
+    /** Base directory for data storage (default: ~/.macro-agent) */
+    baseDir?: string;
+    /** Default permission mode for spawned agents */
+    defaultPermissionMode?: PermissionMode;
+    /** Default agent type (default: "claude-code") */
+    defaultAgentType?: string;
+    /** Role registry (default: DefaultRoleRegistry with built-in roles) */
+    roleRegistry?: RoleRegistry;
+    /** Workspace manager for git worktree isolation */
+    workspaceManager?: WorkspaceManager;
+    /** Inbox adapter config overrides */
+    inbox?: Partial<InboxAdapterConfig>;
+    /** Tasks adapter config overrides */
+    tasks?: Partial<TasksAdapterConfig>;
+    /** Trigger system config */
+    trigger?: {
+        enableHeartbeat?: boolean;
+        heartbeatIntervalMs?: number;
+    };
+    /** Server URL for MCP thin-client mode */
+    serverUrl?: string;
+    /** Server token for thin-client auth */
+    serverToken?: string;
+    /** REST API server config */
+    api?: {
+        enabled?: boolean;
+        port?: number;
+        host?: string;
+    };
+    /** ACP WebSocket server config */
+    acp?: {
+        enabled?: boolean;
+        port?: number;
+        host?: string;
+        path?: string;
+    };
+    /** Federation config for cross-instance communication */
+    federation?: {
+        systemId: string;
+        peers?: Array<{
+            systemId: string;
+            url?: string;
+            meshPeerId?: string;
+        }>;
+        trust?: {
+            allowedSystems?: string[];
+        };
+    };
+    /** MAP server config (accept inbound connections from TUI/clients) */
+    mapServer?: {
+        enabled?: boolean;
+        port?: number;
+        host?: string;
+        path?: string;
+        name?: string;
+    };
+    /** MAP sidecar config (connect to OpenHive hub) */
+    map?: {
+        enabled?: boolean;
+        server?: string;
+        token?: string;
+        scope?: string;
+        systemId?: string;
+        credential?: string;
+        agentName?: string;
+        trajectorySyncLevel?: "off" | "lifecycle" | "metrics" | "full";
+        reconnectIntervalMs?: number;
+        reconnection?: {
+            enabled?: boolean;
+            maxRetries?: number;
+            baseDelayMs?: number;
+            maxDelayMs?: number;
+        };
+    };
+    /** minimem (agent memory) — registers as MCP server for all agents */
+    minimem?: {
+        enabled?: boolean;
+        dir?: string;
+        provider?: string;
+        global?: boolean;
+    };
+    /** skill-tree (per-role skills) — compiles loadouts at team start, injects into prompts */
+    skilltree?: {
+        enabled?: boolean;
+        basePath?: string;
+        defaultProfile?: string;
+    };
+    /** sessionlog — enriches trajectory checkpoints with session state data */
+    sessionlog?: {
+        enabled?: boolean;
+        sync?: "off" | "lifecycle" | "metrics" | "full";
+    };
+    /** agentic-mesh — P2P encrypted transport for MAP sidecar */
+    mesh?: {
+        enabled?: boolean;
+        peerId?: string;
+    };
+}
+interface MacroAgentSystemV2 {
+    /** Agent lifecycle manager */
+    agentManager: AgentManager;
+    /** Agent lifecycle store */
+    agentStore: AgentStore;
+    /** Messaging adapter (embedded agent-inbox) */
+    inboxAdapter: InboxAdapter;
+    /** Task management adapter (opentasks client) */
+    tasksAdapter: TasksAdapter;
+    /** Trigger system (wake, cron, webhooks) */
+    triggerSystem: TriggerSystemV2;
+    /** Control server (lifecycle RPC for MCP subprocesses) */
+    controlServer: ControlServer;
+    /** Role registry */
+    roleRegistry: RoleRegistry;
+    /** Control socket path (for MCP subprocess connection) */
+    controlSocketPath: string;
+    /** REST API server (if enabled) */
+    apiServer?: ApiServer;
+    /** ACP WebSocket server (if enabled) */
+    acpServer?: WebSocketACPServer;
+    /** MAP server for inbound connections (if enabled) */
+    mapServerInstance?: MAPServerInstance;
+    /** MAP sidecar for outbound hub connection (if enabled) */
+    mapSidecar?: MAPSidecar;
+    /** Sessionlog sync level for trajectory checkpoint gating */
+    _sessionlogSyncLevel?: string;
+    /** Shut down all components */
+    shutdown(): Promise<void>;
+}
+declare function bootV2(config?: BootV2Config): Promise<MacroAgentSystemV2>;
+
+export { type AgentId$1 as A, type BootV2Config as B, type Capability as C, DefaultInboxAdapter as D, type EventId as E, type SessionId as F, type AgentConfig as G, type HeadManagerOptions as H, type InboxAdapter as I, type SpawnAgentOptions as J, type SpawnInterceptor as K, type SpawnedAgent as L, type MAPSidecarDeps as M, type StopReason as N, type TrajectoryCheckpointPayload as O, type TrajectoryCheckpointResult as P, type Workspace as Q, type RoleRegistry as R, type SystemPromptContext as S, type Timestamp as T, bootV2 as U, type WorkspaceManager as W, type TaskId$1 as a, AgentStore as b, type TasksAdapter as c, type AgentManager as d, type RoleConfig as e, type RoleDefinition as f, type MAPSidecarConfig as g, type MAPSidecar as h, type MacroAgentSystemV2 as i, type MapServerConfig as j, type MAPServerInstance as k, type ActiveSession as l, type Agent as m, type AgentConfig$1 as n, type AgentFilter as o, type AgentHierarchy as p, type AgentHierarchyNode as q, type AgentLifecycleCallback as r, type AgentLifecycleEvent as s, type MCPServerConfig as t, type AgentManagerConfig as u, AgentManagerError as v, type AgentManagerErrorCode as w, type AgentState as x, type AgentStopReason as y, DefaultTasksAdapter as z };