macro-agent 0.1.5 → 0.1.7

package/.claude/settings.json

@@ -1,6 +1,133 @@
 {
-    "attribution": {
+  "attribution": {
     "commit": "",
     "pr": ""
+  },
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "sessionlog hooks claude-code session-start"
+          }
+        ]
+      }
+    ],
+    "SessionEnd": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "sessionlog hooks claude-code session-end"
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "sessionlog hooks claude-code user-prompt-submit"
+          }
+        ]
+      }
+    ],
+    "Stop": [
+      {
+        "matcher": "",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "sessionlog hooks claude-code stop"
+          }
+        ]
+      }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "Task",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "sessionlog hooks claude-code pre-task"
+          }
+        ]
+      }
+    ],
+    "PostToolUse": [
+      {
+        "matcher": "Task",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "sessionlog hooks claude-code post-task"
+          }
+        ]
+      },
+      {
+        "matcher": "TodoWrite",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "sessionlog hooks claude-code post-todo"
+          }
+        ]
+      },
+      {
+        "matcher": "TaskCreate",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "sessionlog hooks claude-code post-task-create"
+          }
+        ]
+      },
+      {
+        "matcher": "TaskUpdate",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "sessionlog hooks claude-code post-task-update"
+          }
+        ]
+      },
+      {
+        "matcher": "EnterPlanMode",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "sessionlog hooks claude-code post-plan-enter"
+          }
+        ]
+      },
+      {
+        "matcher": "ExitPlanMode",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "sessionlog hooks claude-code post-plan-exit"
+          }
+        ]
+      },
+      {
+        "matcher": "Skill",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "sessionlog hooks claude-code post-skill"
+          }
+        ]
+      }
+    ]
+  },
+  "permissions": {
+    "deny": [
+      "Read(./.sessionlog/metadata/**)"
+    ]
   }
 }

package/.sessionlog/settings.json

@@ -0,0 +1,4 @@
+{
+  "enabled": true,
+  "strategy": "manual-commit"
+}

package/CLAUDE.md

@@ -1,11 +1,11 @@
 # macro-agent
 
-A multi-agent orchestration system for spawning and managing hierarchical Claude Code agents. Delegates messaging to **agent-inbox** and task management to **opentasks**.
+A multi-agent orchestration system for spawning and managing hierarchical AI coding agents. Delegates messaging to **agent-inbox** and task management to **opentasks**. Exposes ACP (WebSocket) and REST API servers, supports cross-instance federation, and can serve as a compute backend for cognitive-core/OpenHive.
 
 ## Project Overview
 
 macro-agent enables coordinated work across multiple AI agents with:
-- **Role-based agents** (Worker, Integrator, Coordinator, Monitor + custom team roles)
+- **Role-based agents** (Worker, Integrator, Coordinator, Monitor, Analyst + custom team roles)
 - **Team templates** for declarative multi-agent topologies (YAML config)
 - **Pluggable integration strategies** (queue, trunk, optimistic)
 - **Workspace isolation** via git worktrees (powered by git-cascade)
@@ -14,24 +14,30 @@ macro-agent enables coordinated work across multiple AI agents with:
 - **Task management** via opentasks (graph-based dependencies, providers, claiming)
 - **Control socket** for MCP subprocess lifecycle RPC (NDJSON over UNIX socket)
 - **Composite signal filtering and emission enforcement** for multi-team communication topology
-- **Trigger system** with pluggable routing strategies, wake management, cron, and webhooks
+- **Trigger system** with pluggable routing strategies (including AI router), wake management, cron, and webhooks
 - **Agent detection** for discovering installed CLI coding agents (Claude Code, Codex, etc.)
 - **Health check heartbeats** from MCP subprocesses to the control server
+- **ACP protocol server** with WebSocket transport for external client integration
+- **REST API server** for HTTP-based agent, task, team, and metrics management
+- **Federation** for cross-instance communication between macro-agent instances
+- **Cognitive-core backend** for serving as compute backend for OpenHive
+- **Metrics collection** for point-in-time system observability
 
 ## Architecture
 
 ```
 ┌─────────────────────────────────────────────────────────────┐
 │                      External Clients                       │
-│                     (CLI, ACP stdio)                        │
+│             (CLI, ACP stdio, WebSocket, REST API)           │
 └───────────────────────────┬─────────────────────────────────┘
                             │
 ┌───────────────────────────▼─────────────────────────────────┐
 │                   boot-v2.ts (System Wiring)                │
-│  1. AgentStore (SQLite)      5. AgentManagerV2              │
-│  2. InboxAdapter (embedded)  6. TriggerSystemV2             │
-│  3. TasksAdapter (IPC)       7. ControlServer               │
-│  4. RoleRegistry             8. Return MacroAgentSystemV2   │
+│  1. AgentStore (SQLite)       6. TriggerSystemV2            │
+│  2. InboxAdapter (embedded)   7. ControlServer              │
+│  3. TasksAdapter (IPC)        8. Federation (optional)      │
+│  4. RoleRegistry              9. REST API server (optional)  │
+│  5. AgentManagerV2           10. ACP WebSocket (optional)    │
 └───────────────────────────┬─────────────────────────────────┘
                             │
 ┌───────────────────────────▼─────────────────────────────────┐
@@ -116,12 +122,21 @@ macro-agent enables coordinated work across multiple AI agents with:
 
 ```
 src/
+├── acp/                     # ACP protocol server
+│   ├── macro-agent.ts          # ACP-to-macro-agent bridge (session/new, session/prompt, extensions)
+│   ├── websocket-server.ts     # WebSocket server for ACP clients
+│   ├── session-mapper.ts       # Maps ACP sessions to agent states
+│   ├── map-bridge.ts           # Bridges between MAP and macro-agent protocols
+│   ├── types.ts                # Protocol type definitions (MacroAgentInitConfig, ACPError)
+│   └── index.ts                # Public exports
+│
 ├── adapters/                # Subsystem integration layer
 │   ├── types.ts                # InboxAdapter + TasksAdapter interfaces
 │   ├── inbox-adapter.ts        # Wraps agent-inbox (embedded, hybrid IPC)
 │   ├── inbox-client-adapter.ts # IPC-only client for MCP subprocesses
 │   ├── tasks-adapter.ts        # Wraps opentasks client (IPC to daemon)
 │   ├── opentasks-daemon.ts     # Daemon lifecycle helper (start/stop/probe)
+│   ├── federation.ts           # Cross-instance communication via federated inboxes
 │   └── index.ts                # Public exports
 │
 ├── agent/                   # Agent lifecycle
@@ -142,6 +157,11 @@ src/
 │   ├── command-builder.ts      # Builds headless invocation commands
 │   └── index.ts                # Public exports
 │
+├── api/                     # REST API server
+│   ├── server.ts               # HTTP endpoints for agents, tasks, teams, metrics
+│   ├── types.ts                # ApiServer, ApiServerConfig interfaces
+│   └── index.ts                # Public exports
+│
 ├── auth/                    # Authentication
 │   ├── token.ts                # AgentTokenManager for per-agent auth tokens
 │   └── index.ts                # Public exports
@@ -155,6 +175,14 @@ src/
 │   ├── parse-args.ts           # Argument parsing helpers
 │   └── stable-instance-id.ts   # Stable instance ID generation
 │
+├── cognitive/               # cognitive-core backend integration
+│   ├── macro-agent-backend.ts  # Implements cognitive-core AgentBackend interface
+│   ├── session-converter.ts    # Converts sessions between cognitive-core and macro-agent formats
+│   ├── workspace-handler.ts    # Workspace operations for cognitive backend
+│   ├── analyst-role.ts         # Analyst role definition for cognitive system
+│   ├── types.ts                # CognitiveAgentSession, CognitiveBatchConfig, etc.
+│   └── index.ts                # Public exports
+│
 ├── config/                  # Project configuration
 │   ├── project-config.ts       # .multiagent/config.json loader
 │   └── index.ts                # Public exports
@@ -181,6 +209,11 @@ src/
 │   ├── types.ts                # ToolContext, HierarchyNode, MCPToolError
 │   └── index.ts                # Public exports
 │
+├── metrics/                 # Metrics collection and reporting
+│   ├── metrics.ts              # collectMetrics() — point-in-time agent/task/system snapshot
+│   ├── types.ts                # AgentMetrics, TaskMetrics, SystemMetrics, MetricsSnapshot
+│   └── index.ts                # Public exports
+│
 ├── roles/                   # Role system
 │   ├── types.ts                # RoleDefinition, RoleRegistry, Capability types
 │   ├── capabilities.ts         # Capability constants (AGENT_CAPABILITIES, WORKSPACE_CAPABILITIES)
@@ -224,6 +257,8 @@ src/
 │   │   ├── wake-manager.ts     # Heartbeat + coalesce + inject→interrupt→prompt
 │   │   ├── types.ts
 │   │   └── index.ts
+│   ├── strategies/             # Pluggable routing strategies
+│   │   └── ai-router.ts       # AI-powered routing via temporary Claude session
 │   ├── sources/                # Trigger event sources
 │   │   ├── cron/
 │   │   │   ├── cron-service.ts
@@ -396,6 +431,71 @@ The `agent-detection/` module discovers installed CLI coding agents on the syste
 - Builds headless invocation commands with proper flags
 - Supports custom agent definitions via `additionalAgents` config
 
+### ACP Protocol Server
+
+The `acp/` module bridges the Agent Client Protocol (ACP) to macro-agent's V2 services:
+- **MacroAgent** (`macro-agent.ts`): Implements the ACP Agent interface — maps `session/new` → `agentManager.getOrCreateHeadManager()`, `session/prompt` → streaming `agentManager.prompt()`, and extension methods for spawn/mount/fork/hierarchy/tasks
+- **WebSocketACPServer** (`websocket-server.ts`): Optional WebSocket transport for ACP clients (enabled via `config.acp.enabled` in boot)
+- **SessionMapper** (`session-mapper.ts`): Maps ACP sessions to macro-agent agent states
+- **MAPBridge** (`map-bridge.ts`): Bridges MAP protocol to macro-agent for external observability
+
+### MAP Capabilities
+
+The MAP sidecar (`src/map/sidecar.ts`) declares these capabilities at registration, following the MAP `ParticipantCapabilities` schema:
+
+- `messaging: { canSend: true, canReceive: true }` — can exchange MAP scope messages
+- `mail: { canCreate: true, canJoin: true, canViewHistory: true }` — supports agent-inbox conversations (enables Mail chat mode in OpenHive)
+- `protocols: ['acp']` — advertises ACP protocol support (enables ACP streaming chat in OpenHive)
+- `acp: { version: '2024-10-07' }` — ACP version details
+- `trajectory: { canReport: true, canServeContent: false }` — reports checkpoints (does not serve content on demand)
+- `tasks: { canCreate, canAssign, canUpdate, canList }` — task management
+
+Message delivery is **push-based**: `InboxAdapter.onDelivery()` fires immediately on message receipt, the trigger system maps importance → wake action, and `WakeManager` injects into the active session via inject/interrupt/prompt fallback chain.
+
+### REST API Server
+
+The `api/` module provides HTTP endpoints for external integration:
+- Agent CRUD and listing
+- Task operations
+- Team management
+- Metrics endpoint (powered by `metrics/` module)
+- Enabled via `config.api.enabled` in boot, configurable host/port
+
+### Cognitive-Core Backend
+
+The `cognitive/` module implements cognitive-core's `AgentBackend` interface, enabling macro-agent to serve as a compute backend for OpenHive:
+- **MacroAgentBackend** (`macro-agent-backend.ts`): Spawns analyst agents, tracks sessions, manages timeouts, reports completion via callbacks and InboxAdapter
+- **AnalystRole** (`analyst-role.ts`): Custom role definition for cognitive analysis tasks
+- **SessionConverter** (`session-converter.ts`): Converts between cognitive-core and macro-agent session formats
+- **WorkspaceHandler** (`workspace-handler.ts`): Workspace operations for cognitive backend tasks
+- Design principle: the swarm is pure compute — receive task, execute agent, return result. Atlas, trajectory extraction, and team coordination are handled by OpenHive.
+
+### Federation
+
+The `adapters/federation.ts` module enables cross-instance communication:
+- Multiple macro-agent instances federate their embedded agent-inbox instances
+- Federated addressing: `agentId@systemId` (e.g., `coordinator@dev-laptop`)
+- Cross-instance spawn via convention-based inbox messages (`remote_spawn_request` events)
+- Trust policy: configurable `allowedSystems` whitelist
+- Setup via `config.federation` in boot, cleanup on shutdown
+
+### Metrics
+
+The `metrics/` module provides point-in-time system observability:
+- `collectMetrics()` gathers agent, task, and system metrics into a `MetricsSnapshot`
+- Agent metrics: total/running/stopped/failed counts, unhealthy agent detection
+- Task metrics: total/open/in-progress/closed counts
+- System metrics: uptime, health check status
+- Used by the REST API server's `/metrics` endpoint
+
+### AI Router Strategy
+
+The `trigger/strategies/ai-router.ts` provides an AI-powered routing strategy:
+- Spawns a temporary Claude session to make routing decisions for trigger events
+- Falls back to "head" strategy if spawning fails or times out
+- Selected when `routing.target.type === "ai-router"`
+- Expensive — intended for events that genuinely need intelligent routing
+
 ### Communication Topology
 
 Teams configure communication via:
@@ -434,8 +534,8 @@ All filtering is adapter-side — agent-inbox is a dumb pipe, macro-agent enforc
 
 ### Testing
 
-- **Unit tests**: `*.test.ts` — Fast, mocked dependencies (41 test files)
-- **E2E tests**: `*.e2e.test.ts` — Full system tests (10 test files)
+- **Unit tests**: `*.test.ts` — Fast, mocked dependencies (~40 test files)
+- **E2E tests**: `*.e2e.test.ts` — Full system tests (11 test files)
 
 Run tests:
 ```bash
@@ -447,6 +547,7 @@ npm run test:e2e-full-agents          # E2E tests with real agent spawning (RUN_
 
 E2E test files:
 - `agent-lifecycle.e2e.test.ts` — Spawn, prompt, terminate flows
+- `cognitive-workspace.e2e.test.ts` — Cognitive-core backend workspace operations
 - `done-scenarios.e2e.test.ts` — Done handler scenarios per role
 - `workspace-lifecycle.e2e.test.ts` — Worktree allocation and cleanup
 - `trigger-wake.e2e.test.ts` — Trigger delivery and wake flows
@@ -511,6 +612,18 @@ E2E test files:
 | `MACRO_TEAMS` | Comma-separated team templates to auto-start | -- |
 | `MACRO_AGENT_HOME` | Alternative base directory (used by CLI clear) | `~/.macro-agent` |
 
+### Boot config options (BootV2Config)
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| `api.enabled` | Start REST API server | `false` |
+| `api.port` | REST API port | -- |
+| `acp.enabled` | Start ACP WebSocket server | `false` |
+| `acp.port` | ACP WebSocket port | -- |
+| `federation.systemId` | Unique instance ID for federation | -- |
+| `federation.peers` | Peer instances to federate with | `[]` |
+| `federation.trust.allowedSystems` | Trusted system ID whitelist | -- |
+
 ### Injected into MCP subprocesses (by AgentManagerV2)
 
 | Variable | Description |
@@ -555,6 +668,8 @@ E2E test files:
 | `js-yaml` | Team YAML config parsing |
 | `nanoid` | ID generation |
 | `unique-names-generator` | Human-readable agent names |
+| `express` | REST API server |
+| `ws` | ACP WebSocket transport |
 
 ### Dev
 

package/README.md

@@ -2,20 +2,25 @@
 
 A multi-agent orchestration system for spawning and managing hierarchical AI coding agents. Interact with multiple agents as if they were one.
 
-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).
+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). It exposes ACP (WebSocket) and REST API servers, supports cross-instance federation, and can serve as a compute backend for [cognitive-core](https://github.com/alexngai/cognitive-core)/OpenHive.
 
 ## Features
 
 - **Hierarchical Agent Management** — Head manager spawns and coordinates child agents via acp-factory
-- **Role-Based Agents** — Worker, Integrator, Coordinator, Monitor roles with distinct capabilities
+- **Role-Based Agents** — Worker, Integrator, Coordinator, Monitor, Analyst 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
+- **Trigger System** — Pluggable routing strategies (direct, role, head, AI router) 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.)
+- **ACP Protocol Server** — WebSocket transport bridging ACP protocol to macro-agent services
+- **REST API** — HTTP endpoints for agents, tasks, teams, and metrics
+- **Federation** — Cross-instance communication via federated agent-inbox (addressable as `agentId@systemId`)
+- **Cognitive-Core Backend** — Serves as compute backend for OpenHive (analyst agent spawning, batch execution)
+- **Metrics** — Point-in-time snapshots of agent, task, and system health
 
 ## Installation
 
@@ -77,37 +82,37 @@ npx multiagent --acp
 ## Architecture
 
 ```
-                    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)
-└──────┘ └────────────┘ └────────────┘
+              CLI / ACP stdio / WebSocket / REST API
+                              │
+                         ┌────▼────┐
+                         │ bootV2  │  Wires all components
+                         └────┬────┘
+                              │
+       ┌──────────┬───────────┼───────────┬──────────┐
+       │          │           │           │          │
+ ┌─────▼─────┐ ┌─▼───────┐ ┌▼────────┐ ┌▼───────┐ ┌▼──────────┐
+ │  Agent    │ │ Trigger  │ │ Control │ │  ACP   │ │ REST API  │
+ │  Manager  │ │ System   │ │ Socket  │ │ Server │ │ Server    │
+ │           │ │          │ │ (RPC)   │ │ (WS)   │ │ (HTTP)    │
+ │  spawn    │ │ router   │ └────┬────┘ └────────┘ └───────────┘
+ │  prompt   │ │ wake     │      │
+ │  terminate│ │ cron     │  MCP subprocesses
+ └─────┬─────┘ │ webhook  │  (per agent)
+       │       │ ai-router│
+ ┌─────┼───────┘──────────┐
+ │     │                  │
+┌▼────┐┌▼──────────┐ ┌───▼────────┐
+│Roles││ Workspace  │ │  Adapters  │
+│    ││ Worktrees  │ │            │
+│    ││ Strategies │ │ InboxAdapter ──► agent-inbox (embedded)
+│    ││ MergeQueue │ │ TasksAdapter ──► opentasks  (IPC daemon)
+└────┘└────────────┘ │ Federation ──► remote instances
+                     └────────────┘
 ```
 
 **Three subsystems:**
-- **macro-agent** — Orchestration, lifecycle, teams, workspace, triggers
-- **agent-inbox** — Messaging (embedded in-process, IPC server for subprocesses)
+- **macro-agent** — Orchestration, lifecycle, teams, workspace, triggers, ACP/REST servers, federation, cognitive backend, metrics
+- **agent-inbox** — Messaging (embedded in-process, IPC server for subprocesses, federation)
 - **opentasks** — Task management (separate daemon, IPC client)
 
 ## Team Templates
@@ -163,6 +168,61 @@ Each agent gets tools from three sources:
 
 Custom roles extend built-in roles via YAML with `capabilities_add`/`capabilities_remove`.
 
+## ACP Protocol Server
+
+The ACP server bridges the [Agent Client Protocol](https://github.com/anthropics/acp) to macro-agent:
+
+```typescript
+const system = await bootV2({
+  acp: { enabled: true, port: 8080 },
+});
+```
+
+- Maps `session/new` → head manager creation, `session/prompt` → streaming responses
+- Extension methods: `_macro/spawnAgent`, `_macro/getHierarchy`, `_macro/mountAgent`, `_macro/forkAgent`, etc.
+- WebSocket transport for real-time communication
+
+## REST API
+
+```typescript
+const system = await bootV2({
+  api: { enabled: true, port: 3000 },
+});
+```
+
+HTTP endpoints for agents, tasks, teams, and metrics. Used for dashboards and external tooling.
+
+## Federation
+
+Connect multiple macro-agent instances for cross-instance agent communication:
+
+```typescript
+const system = await bootV2({
+  federation: {
+    systemId: 'dev-laptop',
+    peers: [{ systemId: 'ci-server', url: 'ws://ci:8080' }],
+    trust: { allowedSystems: ['ci-server'] },
+  },
+});
+```
+
+Agents address across instances with `agentId@systemId` (e.g., `coordinator@ci-server`).
+
+## Cognitive-Core Backend
+
+macro-agent can serve as a compute backend for [cognitive-core](https://github.com/alexngai/cognitive-core) / OpenHive:
+
+```typescript
+import { MacroAgentBackend } from 'macro-agent/cognitive';
+
+const backend = new MacroAgentBackend(system.agentManager, {
+  tasksAdapter: system.tasksAdapter,
+  inboxAdapter: system.inboxAdapter,
+});
+```
+
+Spawns analyst agents, manages sessions with timeouts, and reports completion. The swarm is pure compute — atlas, trajectory extraction, and team coordination are handled by OpenHive.
+
 ## Dependencies
 
 | Package | Purpose |
@@ -172,6 +232,8 @@ Custom roles extend built-in roles via YAML with `capabilities_add`/`capabilitie
 | [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 |
+| [express](https://expressjs.com/) | REST API server |
+| [ws](https://github.com/websockets/ws) | ACP WebSocket transport |
 
 ## Testing
 

package/dist/acp/macro-agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"macro-agent.d.ts","sourceRoot":"","sources":["../../src/acp/macro-agent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EACV,KAAK,IAAI,QAAQ,EAclB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAKpE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEpD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAQvD,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,kBAAkB,CAAC;IAC3B,UAAU,CAAC,EAAE,oBAAoB,CAAC;CACnC;AAoFD;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,mBAAmB,EAC/B,MAAM,EAAE,gBAAgB,GACvB,QAAQ,CAoqBV;AAED;;;GAGG;AACH,OAAO,EAAE,aAAa,EAAE,CAAC"}
+{"version":3,"file":"macro-agent.d.ts","sourceRoot":"","sources":["../../src/acp/macro-agent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EACV,KAAK,IAAI,QAAQ,EAclB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAKpE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEpD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAQvD,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,kBAAkB,CAAC;IAC3B,UAAU,CAAC,EAAE,oBAAoB,CAAC;CACnC;AAoFD;;;;;;;;;;GAUG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,mBAAmB,EAC/B,MAAM,EAAE,gBAAgB,GACvB,QAAQ,CAiqBV;AAED;;;GAGG;AACH,OAAO,EAAE,aAAa,EAAE,CAAC"}

package/dist/acp/macro-agent.js

@@ -290,9 +290,7 @@ export function createMacroAgent(connection, config) {
         async newSession(params) {
             const cwd = params.cwd ?? defaultCwd;
             // Get or create a head manager for this workspace
-            const headManager = await agentManager.getOrCreateHeadManager({
-                cwd,
-            });
+            const headManager = await agentManager.getOrCreateHeadManager({ cwd });
             // Create session mapping
             const mapping = sessionMapper.createMapping(headManager.session_id, headManager.id);
             // Annotate sessionlog with swarm metadata (best effort)