macro-agent 0.1.2 → 0.1.4

package/README.md

@@ -1,63 +1,21 @@
 # macro-agent
 
-A multi-agent orchestration system for spawning and managing hierarchical Claude Code agents. Interact with multiple agents as if they were one.
+A multi-agent orchestration system for spawning and managing hierarchical AI coding agents. Interact with multiple agents as if they were one.
 
-## Features
-
-- **Hierarchical Agent Management** - Head manager spawns and coordinates child agents
-- **Role-Based Agents** - Worker, Integrator, Coordinator, and Monitor roles with distinct capabilities
-- **Team Templates** - Declarative YAML-based team configurations for multi-agent topologies
-- **Pluggable Integration Strategies** - Queue, trunk, or optimistic merge strategies
-- **Workspace Isolation** - Each worker gets isolated git worktrees to prevent conflicts
-- **Merge Queue** - Serialized integration of worker changes with conflict resolution
-- **Event-Sourced State** - All state changes persisted via append-only event log
-- **Real-time Communication** - WebSocket subscriptions for live updates
-- **MCP Tool Integration** - Agents communicate via Model Context Protocol tools
-- **Task Lifecycle** - Create, assign, and track tasks with push or pull models
-- **Message Routing** - Direct, broadcast, role-based, and topic-based message delivery with priority
-- **Signal Filtering** - Per-role and per-peer signal filtering for status notifications
-- **Context Injection** - Push context into running agents without waiting for message checks
-- **Session Continuations** - Auto-resume long-running agents across process restarts
-- **Observability** - Throughput, utilization, and error metrics via REST API
-- **OpenTasks Integration** - Optional issue tracking with dependency management
-
-## Team Templates
-
-Teams define multi-agent topologies as YAML configuration. A team template specifies which roles to spawn, how they communicate, and what integration strategy to use.
-
-```bash
-# Start with a team template
-npx multiagent --team self-driving
-
-# Or set in project config (.multiagent/config.json)
-echo '{ "team": "self-driving" }' > .multiagent/config.json
-npx multiagent
-```
-
-Teams are stored in `.multiagent/teams/<name>/`:
-
-```
-.multiagent/teams/self-driving/
-├── team.yaml          # Team manifest (topology, communication, strategy)
-├── roles/
-│   ├── planner.yaml   # Custom role (extends coordinator)
-│   ├── grinder.yaml   # Custom role (extends worker)
-│   └── judge.yaml     # Custom role (extends monitor)
-└── prompts/
-    ├── planner.md     # Role-specific system prompt
-    ├── grinder.md
-    └── judge.md
-```
+macro-agent handles **orchestration** (agent lifecycle, team topology, workspace isolation, trigger/wake) and delegates **messaging** to [agent-inbox](https://github.com/alexngai/agent-inbox) and **task management** to [opentasks](https://github.com/alexngai/opentasks).
 
-Key team features:
-- **Topology**: Root + companion agents spawned at bootstrap, with spawn rules for dynamic workers
-- **Communication**: Topic-based channels with per-role signal filtering, peer-to-peer routing
-- **Integration strategies**: `queue` (merge queue), `trunk` (direct push with rebase), `optimistic` (push + validation)
-- **Task modes**: `push` (coordinator assigns) or `pull` (agents claim from pool)
-- **Enforcement**: `strict` (reject violations), `permissive` (warn), or `audit` (record)
-- **Session continuations**: Auto-resume daemon agents on unexpected stops
+## Features
 
-See [docs/teams.md](docs/teams.md) for the full schema reference and [docs/team-templates.md](docs/team-templates.md) for examples.
+- **Hierarchical Agent Management** — Head manager spawns and coordinates child agents via acp-factory
+- **Role-Based Agents** — Worker, Integrator, Coordinator, Monitor roles with distinct capabilities
+- **Team Templates** — Declarative YAML configs for multi-agent topologies with composite signal filtering
+- **Workspace Isolation** — Each worker gets an isolated git worktree via git-cascade
+- **Merge Queue** — Serialized integration of worker changes with conflict resolution
+- **Control Socket** — NDJSON-over-UNIX-socket RPC for MCP subprocess lifecycle operations
+- **Trigger System** — Pluggable routing strategies for wake, cron, and webhook-based agent activation
+- **MCP Tools** — 5 core orchestration tools + 3 pull-mode claim tools per agent
+- **Task Modes** — Push (coordinator assigns) or pull (agents claim from pool)
+- **Agent Detection** — Auto-discovers installed CLI coding agents (Claude Code, Codex, etc.)
 
 ## Installation
 
@@ -67,23 +25,33 @@ npm install macro-agent
 
 ## Quick Start
 
-### Server Mode (Default)
+### Programmatic Usage
 
-```bash
-# Start full server with ACP + MAP + REST API
-npx multiagent
+```typescript
+import { bootV2 } from 'macro-agent';
 
-# Start with a team template
-npx multiagent --team self-driving
+// Boot the system — initializes AgentStore, InboxAdapter, TasksAdapter,
+// AgentManager, TriggerSystem, and ControlServer
+const system = await bootV2({ cwd: process.cwd() });
+
+// Create a head manager agent
+const headManager = await system.agentManager.getOrCreateHeadManager({
+  cwd: process.cwd(),
+});
+
+// Send a prompt and stream the response
+for await (const update of system.agentManager.prompt(headManager.id, 'Build feature X')) {
+  // Handle streaming response
+}
 
-# Custom port and host
-npx multiagent --port 8080 --host 0.0.0.0
+// Shut down cleanly
+await system.shutdown();
 ```
 
-### CLI Tools
+### CLI
 
 ```bash
-# Start interactive chat
+# Start the system and enter interactive chat
 npx multiagent-cli chat
 
 # Check system status
@@ -95,350 +63,140 @@ npx multiagent-cli hierarchy
 # List all agents
 npx multiagent-cli agents
 
-# List all tasks
-npx multiagent-cli tasks
-```
-
-### Programmatic Usage
-
-```typescript
-import {
-  createEventStore,
-  createAgentManager,
-  createTaskManager,
-  createMessageRouter,
-  createAPIServer,
-} from 'macro-agent';
-
-// Initialize the system
-const eventStore = await createEventStore({ inMemory: true });
-const messageRouter = createMessageRouter(eventStore);
-const taskManager = createTaskManager(eventStore);
-const agentManager = createAgentManager(eventStore, messageRouter, {
-  defaultPermissionMode: 'auto-approve',
-});
-
-// Create a head manager
-const headManager = await agentManager.getOrCreateHeadManager({
-  cwd: process.cwd(),
-});
-
-// Send a message
-for await (const update of agentManager.prompt(headManager.id, 'Hello!')) {
-  // Handle streaming response
-}
+# Stop an agent or all agents
+npx multiagent-cli stop <agentId>
+npx multiagent-cli stop --all
 
-// Start the API server
-const { app, server, wss } = createAPIServer({
-  eventStore,
-  agentManager,
-  taskManager,
-  messageRouter,
-});
+# Clear all data (agents.db, inbox.db)
+npx multiagent-cli clear
 
-server.listen(3000);
+# Start as ACP server (for embedding via acp-factory)
+npx multiagent --acp
 ```
 
 ## Architecture
 
 ```
-┌─────────────────────────────────────────────────────────────┐
-│                        User                                  │
-│                          │                                   │
-│                          ▼                                   │
-│  ┌──────────┐     ┌─────────────┐     ┌──────────────────┐  │
-│  │   CLI    │────▶│  API Server │────▶│   WebSocket      │  │
-│  └──────────┘     └─────────────┘     └──────────────────┘  │
-│                          │                                   │
-│                          ▼                                   │
-│  ┌───────────────────────────────────────────────────────┐  │
-│  │                   Agent Manager                        │  │
-│  │  ┌─────────────┐  ┌─────────────┐  ┌──────────────┐   │  │
-│  │  │Head Manager │──│ Child Agent │──│ Child Agent  │   │  │
-│  │  └─────────────┘  └─────────────┘  └──────────────┘   │  │
-│  └───────────────────────────────────────────────────────┘  │
-│                          │                                   │
-│         ┌────────────────┼────────────────┐                 │
-│         ▼                ▼                ▼                 │
-│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐         │
-│  │Task Manager │  │Msg Router   │  │ MCP Server  │         │
-│  └─────────────┘  └─────────────┘  └─────────────┘         │
-│                          │                                   │
-│                          ▼                                   │
-│  ┌───────────────────────────────────────────────────────┐  │
-│  │                   Event Store                          │  │
-│  │    (Append-only log + Materialized Views)             │  │
-│  └───────────────────────────────────────────────────────┘  │
-└─────────────────────────────────────────────────────────────┘
-```
-
-## Role System
-
-Agents are assigned roles that determine their capabilities:
-
-| Role | Purpose | Key Capabilities |
-|------|---------|------------------|
-| **Worker** | Execute tasks in isolated workspace | File I/O, git operations, task completion |
-| **Integrator** | Manage merge queue and resolve conflicts | Merge operations, branch management |
-| **Coordinator** | Orchestrate workers and manage tasks | Spawn agents, assign tasks, broadcast |
-| **Monitor** | Health monitoring and alerts | Read-only access, activity watching |
+                    CLI / ACP Client
+                         │
+                    ┌────▼────┐
+                    │ bootV2  │  Wires all components
+                    └────┬────┘
+                         │
+          ┌──────────────┼──────────────┐
+          │              │              │
+    ┌─────▼─────┐  ┌────▼────┐  ┌──────▼──────┐
+    │  Agent    │  │ Trigger │  │  Control    │
+    │  Manager  │  │ System  │  │  Socket     │
+    │           │  │         │  │  (lifecycle │
+    │  spawn    │  │ router  │  │   RPC)      │
+    │  prompt   │  │ wake    │  └──────┬──────┘
+    │  terminate│  │ cron    │         │
+    └─────┬─────┘  │ webhook │    MCP subprocesses
+          │        └─────────┘    (per agent)
+          │
+    ┌─────┼──────────────┐
+    │     │              │
+┌───▼──┐ ┌▼──────────┐ ┌▼───────────┐
+│Roles │ │ Workspace  │ │  Adapters  │
+│      │ │ Worktrees  │ │            │
+│      │ │ Strategies │ │ InboxAdapter ──► agent-inbox (embedded)
+│      │ │ MergeQueue │ │ TasksAdapter ──► opentasks  (IPC daemon)
+└──────┘ └────────────┘ └────────────┘
+```
+
+**Three subsystems:**
+- **macro-agent** — Orchestration, lifecycle, teams, workspace, triggers
+- **agent-inbox** — Messaging (embedded in-process, IPC server for subprocesses)
+- **opentasks** — Task management (separate daemon, IPC client)
 
-```typescript
-// Spawn a worker agent
-const worker = await agentManager.spawn({
-  task: 'Implement feature X',
-  role: 'worker',
-  parent: headManagerId,
-});
-```
-
-## Workspace Isolation
-
-Each worker operates in an isolated git worktree:
-
-```
-Main Repository
-├── .worktrees/
-│   ├── worker-01/  → feature/task-123 (Worker A)
-│   ├── worker-02/  → feature/task-456 (Worker B)
-│   └── worker-03/  → feature/task-789 (Worker C)
-└── integration     → Merge queue target
-```
-
-- Workers cannot affect each other's work
-- Changes merge through the queue in order
-- Conflicts detected and resolved by Integrator
-
-## Context Injection
-
-Push context into running agents without waiting for message checks:
-
-```typescript
-// Via API
-await fetch('/api/agents/{agentId}/inject', {
-  method: 'POST',
-  body: JSON.stringify({
-    content: 'Priority change: pause current work',
-    urgent: true,
-  }),
-});
-
-// Via MCP tool (agent-to-agent)
-await injectContext(deps, targetAgentId, 'Build is failing', {
-  urgent: true,
-  reason: 'CI failure detected',
-});
-```
-
-Fallback chain: `inject()` → `interruptWith()` → high-priority message
-
-## API Reference
-
-### REST Endpoints
-
-| Endpoint | Method | Description |
-|----------|--------|-------------|
-| `/api/status` | GET | System status |
-| `/api/init` | POST | Initialize head manager |
-| `/api/agents` | GET | List all agents |
-| `/api/agents/:id` | GET | Get agent details |
-| `/api/agents/:id/hierarchy` | GET | Get agent hierarchy |
-| `/api/agents/:id/inject` | POST | Inject context into agent |
-| `/api/tasks` | GET | List all tasks |
-| `/api/tasks/:id` | GET | Get task details |
-| `/api/events` | GET | List events |
-| `/api/conversation/message` | POST | Send message |
-| `/api/conversation/history` | GET | Get history |
-| `/api/team` | GET | Active team info |
-| `/api/metrics/throughput` | GET | Task completion rates |
-| `/api/metrics/utilization` | GET | Agent counts by role/state |
-| `/api/metrics/errors` | GET | Error tracking |
-
-### WebSocket Channels
-
-- `agents` - Agent lifecycle events
-- `tasks` - Task status changes
-- `conversation` - Chat messages
-- `events` - All system events
-
-### MCP Tools (Available to Agents)
-
-| Tool | Description |
-|------|-------------|
-| `spawn_agent` | Spawn a child agent |
-| `emit_status` | Report status (with signal filtering and emission validation) |
-| `send_message` | Send message to another agent |
-| `check_messages` | Check message inbox |
-| `get_hierarchy` | View agent tree |
-| `get_agent_summary` | Get agent details |
-| `stop_agent` | Terminate an agent |
-| `create_task` | Create a new task |
-| `get_task` | Get task details |
-| `list_tasks` | List tasks with optional filters |
-| `assign_task` | Assign task to agent |
-| `task` | Upsert task (OpenTasks only) |
-| `link` | Link tasks (OpenTasks only) |
-| `annotate` | Add annotations (OpenTasks only) |
-| `claim_task` | Claim next available task (pull mode) |
-| `unclaim_task` | Return claimed task to pool (pull mode) |
-| `list_claimable_tasks` | List claimable tasks (pull mode) |
-| `done` | Signal task completion (role-specific) |
-| `inject_context` | Inject context into another agent |
-| `wait_for_activity` | Wait for system events (Monitor) |
-
-## Server Mode (ACP + MAP)
-
-macro-agent runs as an ACP-compliant agent server with MAP (Multi-Agent Protocol) support, enabling external systems to spawn and control agents programmatically.
-
-### Full Server Mode (Default)
-
-```bash
-# Start combined server with all protocols
-npx multiagent
-
-# Custom configuration
-npx multiagent --port 8080 --host 0.0.0.0 --cwd /path/to/project
-```
+## Team Templates
 
-### Stdio ACP (Embedded Use)
+Teams define multi-agent topologies as YAML configuration:
 
 ```bash
-# Run as stdio ACP server (for spawning via acp-factory)
-npx multiagent --acp
-npx multiagent --acp --cwd /path/to/project
+# Start with a team template
+npx multiagent --team self-driving
 ```
 
-### Server Options
-
-| Option | Description |
-|--------|-------------|
-| `--port <port>` | Server port (default: 3001) |
-| `--host <host>` | Server host (default: localhost) |
-| `--cwd <path>` | Working directory for agents |
-| `--team <name>` | Load team template from `.multiagent/teams/<name>/` |
-| `--acp` | Stdio ACP-only mode (for embedded use with acp-factory) |
-
-### Multi-Client Architecture
-
-When using WebSocket ACP, each client gets its own ACP session but all sessions share the same agent hierarchy:
+Teams are stored in `.multiagent/teams/<name>/`:
 
 ```
-┌─────────────────────────────────────────────────────────────┐
-│                   External Clients                          │
-│  ┌──────────┐  ┌──────────┐  ┌──────────┐                  │
-│  │ Client A │  │ Client B │  │ Client C │                  │
-│  └────┬─────┘  └────┬─────┘  └────┬─────┘                  │
-│       │             │             │                         │
-│       └─────────────┼─────────────┘                         │
-│                     │ WebSocket ACP (JSON-RPC 2.0)          │
-│                     ▼                                       │
-│  ┌───────────────────────────────────────────────────────┐  │
-│  │              WebSocket ACP Server                     │  │
-│  │    (Each connection = independent ACP session)        │  │
-│  └───────────────────────────────────────────────────────┘  │
-│                     │                                       │
-│                     ▼                                       │
-│  ┌───────────────────────────────────────────────────────┐  │
-│  │           Shared Agent Manager                        │  │
-│  │  ┌─────────────┐  ┌─────────────┐  ┌──────────────┐   │  │
-│  │  │Head Manager │──│ Child Agent │──│ Child Agent  │   │  │
-│  │  └─────────────┘  └─────────────┘  └──────────────┘   │  │
-│  └───────────────────────────────────────────────────────┘  │
-└─────────────────────────────────────────────────────────────┘
+.multiagent/teams/self-driving/
+├── team.yaml          # Team manifest (topology, communication, strategy)
+├── roles/
+│   ├── planner.yaml   # Custom role (extends coordinator)
+│   └── grinder.yaml   # Custom role (extends worker)
+└── prompts/
+    ├── planner.md     # Role-specific system prompt
+    └── grinder.md
 ```
 
-Each client can:
-- Create independent sessions via `newSession()`
-- Mount to different agents in the hierarchy
-- Send prompts to their mounted agents
-- See agents spawned by other clients
-
-### Programmatic Usage
-
-```typescript
-import { registerMacroAgent } from 'macro-agent';
-import { AgentFactory } from 'acp-factory';
-
-// Register macro-agent with acp-factory (uses --acp flag for stdio mode)
-registerMacroAgent();
-
-// Spawn via ACP (stdio mode)
-const handle = await AgentFactory.spawn('macro-agent', {
-  permissionMode: 'auto-approve',
-});
+Key team features:
+- **Topology**: Root + companion agents spawned at bootstrap, with spawn rules for dynamic workers
+- **Communication**: Topic-based channels with per-role signal filtering and peer-to-peer routing
+- **Multi-team**: Multiple teams run concurrently with composite signal filters and emission validators
+- **Integration strategies**: `queue` (merge queue), `trunk` (direct push), `optimistic` (push + validation)
+- **Task modes**: `push` (coordinator assigns) or `pull` (agents claim from pool)
 
-// Or connect to server mode (default when running `multiagent`)
-const acpWs = new WebSocket('ws://localhost:3001/acp');   // ACP protocol
-const mapWs = new WebSocket('ws://localhost:3001/map');   // MAP protocol
-```
+See [docs/teams.md](docs/teams.md) for the full schema reference.
 
-## CLI Commands
+## MCP Tools
 
-### multiagent (Server)
+Each agent gets tools from three sources:
 
-```
-multiagent [options]          Start the agent server (full mode by default)
-  --port <port>               Port (default: 3001)
-  --host <host>               Host (default: localhost)
-  --cwd <path>                Working directory
-  --team <name>               Load team template
-  --acp                       Stdio ACP-only mode (for acp-factory)
-```
+| Source | Tools |
+|--------|-------|
+| **macro-agent** | `done`, `spawn_agent`, `stop_agent`, `get_hierarchy`, `inject_context` |
+| **macro-agent** (pull mode) | `claim_task`, `unclaim_task`, `list_claimable_tasks` |
+| **agent-inbox** (IPC) | `send_message`, `check_inbox`, `read_thread`, `list_agents` |
+| **opentasks** (IPC) | `task`, `link`, `annotate`, `query` |
 
-Server endpoints (default mode):
-- `ws://host:port/acp` - ACP protocol (WebSocket)
-- `ws://host:port/map` - MAP protocol (WebSocket)
-- `ws://host:port/api/ws` - Real-time subscriptions
-- `http://host:port/api/*` - REST API
-- `http://host:port/health` - Health check
+## Role System
 
-### multiagent-cli (Management Tools)
+| Role | Purpose | Key Capabilities |
+|------|---------|------------------|
+| **Worker** | Execute tasks in isolated workspace | File I/O, git operations, task completion |
+| **Integrator** | Manage merge queue and resolve conflicts | Merge operations, branch management |
+| **Coordinator** | Orchestrate workers and manage tasks | Spawn agents, assign tasks, broadcast |
+| **Monitor** | Health monitoring and alerts | Read-only access, activity watching |
 
-```
-multiagent-cli start [options]  Start REST-only server (legacy)
-  -p, --port <port>             Port (default: 3000)
-  -h, --host <host>             Host (default: localhost)
-  --cwd <path>                  Working directory
+Custom roles extend built-in roles via YAML with `capabilities_add`/`capabilities_remove`.
 
-multiagent-cli chat             Interactive chat mode
+## Dependencies
 
-multiagent-cli status           Show system status
+| Package | Purpose |
+|---------|---------|
+| [agent-inbox](https://github.com/alexngai/agent-inbox) | Messaging, threading, federation |
+| [opentasks](https://github.com/alexngai/opentasks) | Task graph, dependencies, claiming |
+| [acp-factory](https://github.com/alexngai/acp-factory) | Agent process management |
+| [openteams](https://github.com/alexngai/openteams) | Team template resolution |
+| [git-cascade](https://github.com/alexngai/git-cascade) | Git worktree and merge operations |
 
-multiagent-cli agents [id]      List agents or show details
+## Testing
 
-multiagent-cli tasks [id]       List tasks or show details
+```bash
+# Unit tests (watch mode)
+npm test
 
-multiagent-cli hierarchy [root] Show agent hierarchy tree
+# Unit tests (single run)
+npx vitest run
 
-multiagent-cli stop [agentId]   Stop agent(s)
+# E2E tests (mocked agent sessions)
+npm run test:e2e
 
-multiagent-cli clear            Reset the system
+# E2E tests with real agent spawning
+RUN_FULL_AGENT_TESTS=true npm run test:e2e-full-agents
 ```
 
 ## Development
 
 ```bash
-# Install dependencies
-npm install
-
-# Build
-npm run build
-
-# Run tests
-npm test
-
-# Run E2E tests (requires ANTHROPIC_API_KEY)
-RUN_E2E_TESTS=true ANTHROPIC_API_KEY=xxx npm run test:e2e
+npm install          # Install dependencies
+npm run build        # Build (TypeScript → dist/)
+npm run dev          # Watch mode build
 ```
 
-## Documentation
-
-- [Architecture Overview](docs/architecture.md) - Full system architecture
-- [Configuration Reference](docs/configuration.md) - Environment variables and config options
-- [Team Templates](docs/team-templates.md) - Team template format and examples
-- [Team Schema Reference](docs/teams.md) - Full YAML schema reference
-- [Troubleshooting Guide](docs/troubleshooting.md) - Common issues and solutions
-
 ## License
 
 MIT

package/dist/acp/index.d.ts

@@ -1,57 +1,15 @@
 /**
- * ACP module - Agent Communication Protocol support for macro-agent
+ * ACP (Agent Communication Protocol) — WebSocket-based multi-client sessions.
  *
- * Enables macro-agent to run as an ACP-compliant agent that external
- * systems can spawn and control.
+ * @module acp
  */
-export interface RegisterOptions {
-    /**
-     * Custom command to run macro-agent in ACP mode.
-     * Defaults to "npx" with args ["multiagent", "--acp"]
-     */
-    command?: string;
-    /**
-     * Custom arguments for the command.
-     * Defaults to ["multiagent", "--acp"]
-     */
-    args?: string[];
-    /**
-     * Environment variables to pass to the process.
-     */
-    env?: Record<string, string>;
-}
-/**
- * Register macro-agent with acp-factory for easy spawning.
- *
- * After calling this, you can spawn macro-agent via:
- * ```typescript
- * const handle = await AgentFactory.spawn("macro-agent", { ... });
- * ```
- *
- * @example
- * ```typescript
- * import { registerMacroAgent } from "macro-agent";
- *
- * // Register with defaults
- * registerMacroAgent();
- *
- * // Or with custom options
- * registerMacroAgent({
- *   command: "node",
- *   args: ["./dist/cli/acp.js"],
- * });
- *
- * // Now spawn it
- * const handle = await AgentFactory.spawn("macro-agent", {
- *   permissionMode: "auto-approve",
- * });
- * ```
- */
-export declare function registerMacroAgent(options?: RegisterOptions): void;
-export type { ACPSessionId, SessionMapping, MacroAgentInitConfig, SubAgentConfig, MCPServerConfig as ACPMCPServerConfig, ACPPermissionMode, SpawnAgentRequest, SpawnAgentResponse, GetHierarchyRequest, GetHierarchyResponse, GetTaskRequest, GetTaskResponse, MountAgentRequest, MountAgentResponse, ForkAgentRequest, ForkAgentResponse, HistoryTurn, GetHistoryRequest, GetHistoryResponse, ACPExtensionMethod, ACPExtensionRequests, ACPExtensionResponses, ACPErrorCode, } from "./types.js";
 export { ACPError } from "./types.js";
+export type { ACPSessionId, ACPErrorCode, SessionMapping, MacroAgentInitConfig, } from "./types.js";
 export { SessionMapper } from "./session-mapper.js";
-export { MacroAgent, type MacroAgentConfig } from "./macro-agent.js";
-export { webSocketStream, isWebSocketOpen, isWebSocketConnecting, type Stream, } from "./websocket-stream.js";
-export { createWebSocketACPServer, type WebSocketACPServer, type WebSocketACPServerConfig, type ACPServices, } from "./websocket-server.js";
+export { createMacroAgent } from "./macro-agent.js";
+export type { MacroAgentConfig } from "./macro-agent.js";
+export { createWebSocketACPServer } from "./websocket-server.js";
+export type { WebSocketACPServer, WebSocketACPServerConfig, } from "./websocket-server.js";
+export { createMAPBridge } from "./map-bridge.js";
+export type { MAPBridge, MAPBridgeConfig, MAPBridgeDeps, MAPMessage, } from "./map-bridge.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/acp/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/acp/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAQH,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAEhB;;OAEG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC9B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,GAAE,eAAoB,GAAG,IAAI,CAYtE;AAOD,YAAY,EACV,YAAY,EACZ,cAAc,EAEd,oBAAoB,EACpB,cAAc,EACd,eAAe,IAAI,kBAAkB,EACrC,iBAAiB,EAEjB,iBAAiB,EACjB,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,cAAc,EACd,eAAe,EACf,iBAAiB,EACjB,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EAEjB,WAAW,EACX,iBAAiB,EACjB,kBAAkB,EAElB,kBAAkB,EAClB,oBAAoB,EACpB,qBAAqB,EAErB,YAAY,GACb,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAGtC,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAGpD,OAAO,EAAE,UAAU,EAAE,KAAK,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAGrE,OAAO,EACL,eAAe,EACf,eAAe,EACf,qBAAqB,EACrB,KAAK,MAAM,GACZ,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EACL,wBAAwB,EACxB,KAAK,kBAAkB,EACvB,KAAK,wBAAwB,EAC7B,KAAK,WAAW,GACjB,MAAM,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/acp/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,YAAY,EACV,YAAY,EACZ,YAAY,EACZ,cAAc,EACd,oBAAoB,GACrB,MAAM,YAAY,CAAC;AAEpB,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEpD,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACpD,YAAY,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AAEzD,OAAO,EAAE,wBAAwB,EAAE,MAAM,uBAAuB,CAAC;AACjE,YAAY,EACV,kBAAkB,EAClB,wBAAwB,GACzB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,YAAY,EACV,SAAS,EACT,eAAe,EACf,aAAa,EACb,UAAU,GACX,MAAM,iBAAiB,CAAC"}