agentcorp-broker 0.1.0-alpha.1

package/docs/guides/human-console.md

@@ -0,0 +1,177 @@
+# Human Oversight Console Guide
+
+AgentCorp provides first-class Human-in-the-Loop (HITL) oversight designed for developer speed. You can review and approve agent actions directly inside your terminal or through a real-time web dashboard.
+
+---
+
+## 1. How It Works: Sequence & State Diagrams
+
+![AgentCorp Human-in-the-Loop Coordination Flow](../images/coordination-flow.jpg)
+
+### A. Inter-Agent Coordination Sequence Diagram
+
+This diagram shows how messages move between agents, how policies are evaluated, and when human oversight is triggered:
+
+```mermaid
+sequenceDiagram
+    autonumber
+    actor Codex as Codex (Architect / Planner)
+    participant Stdio as Stdio Adapter
+    participant Daemon as Central Broker Daemon
+    participant Policy as Policy Engine
+    actor Human as Human Developer (Terminal / Web)
+    actor Gemini as Antigravity (Developer)
+
+    Note over Codex, Gemini: Case 1: Auto-Approved Message (e.g. read_only report)
+    Codex->>Stdio: send_message(to="developer", type="report", risk_tags=["read_only"])
+    Stdio->>Daemon: HTTP POST /mcp (Bearer Token: architect)
+    Daemon->>Policy: Evaluate policies for "report" + ["read_only"]
+    Policy-->>Daemon: MATCH: "allow-read-only-reports" -> action="auto_approve"
+    Daemon->>Daemon: Store in messages (status="delivered")
+    Daemon-->>Gemini: Delivered to Inbox (No human approval needed!)
+    Daemon-->>Stdio: { status: "delivered", messageId: "msg_..." }
+    Stdio-->>Codex: Success
+
+    Note over Codex, Gemini: Case 2: Human-Gated Message (e.g. proposal or task completion)
+    Codex->>Stdio: send_message(to="developer", type="proposal", payload={...})
+    Stdio->>Daemon: HTTP POST /mcp (Bearer Token: architect)
+    Daemon->>Policy: Evaluate policies for "proposal"
+    Policy-->>Daemon: MATCH: "gate-critical-proposals" -> action="require_human"
+    Daemon->>Daemon: Store in pending_approval (Recipient CANNOT see message)
+    Daemon-->>Stdio: { status: "held_for_approval", approvalId: "apr_..." }
+    Stdio-->>Codex: Queued for Human Sign-off
+
+    Note over Human, Daemon: Human Review Session (agentcorp review)
+    Human->>Daemon: agentcorp review (or web console)
+    Daemon-->>Human: Displays pending approval & payload preview
+    Human->>Daemon: Press [a] Approve (or [e] Edit & Approve, [r] Reject)
+    Daemon->>Daemon: Update approval (status="approved"), message (status="delivered")
+    Daemon->>Daemon: Activate linked task as assigned
+    Daemon-->>Gemini: Approved handoff appears in get_work_queue
+    Gemini->>Daemon: accept_handoff("msg_...")
+    Daemon->>Daemon: Acknowledge proposal and start task
+```
+
+---
+
+### B. Lifecycle State Diagrams
+
+#### Message Lifecycle State Machine
+
+```mermaid
+stateDiagram-v2
+    [*] --> Submitted: send_message()
+    
+    state "Policy Evaluation" as Eval
+    Submitted --> Eval
+    
+    Eval --> Delivered: Rule matches "auto_approve"<br/>(e.g. read_only reports)
+    Eval --> PendingApproval: Rule matches "require_human"<br/>or no rule matches (Safe default)
+    
+    state "Human Decision (agentcorp review)" as Decision
+    PendingApproval --> Decision
+    
+    Decision --> Delivered: Human [a]pproves or [e]dits
+    Decision --> Rejected: Human [r]ejects
+    
+    Delivered --> Acknowledged: Recipient calls acknowledge_message()
+    
+    Acknowledged --> [*]
+    Rejected --> [*]
+```
+
+#### Task Lifecycle State Machine
+
+```mermaid
+stateDiagram-v2
+    [*] --> proposed: create_task()
+    proposed --> assigned: Linked proposal approved
+    assigned --> in_progress: Agent calls accept_handoff
+    in_progress --> blocked: Agent encounters dependency
+    blocked --> in_progress: Dependency resolved
+    
+    state "Policy Evaluation" as TaskPolicy
+    in_progress --> TaskPolicy: update_task_status("completed")
+    
+    TaskPolicy --> PendingSignOff: "gate-task-completion" policy
+    PendingSignOff --> completed: Human verifies & signs off [a]
+    PendingSignOff --> in_progress: Human rejects completion [r]
+    
+    in_progress --> cancelled: Task abandoned
+    completed --> [*]
+    cancelled --> [*]
+```
+
+---
+
+## 2. Terminal-Native Interaction (Preferred)
+
+Terminal-native interaction provides instantaneous, zero-latency review without context switching into a browser.
+
+### A. Dashboard Overview (`agentcorp console`)
+Run the console command to view system status, task counts, and pending approvals:
+
+```sh
+agentcorp console
+```
+
+Example output (the automatically selected port varies):
+```text
+┌─────────────────────────────────────────────────────────────┐
+│  AGENTCORP  ::  Human Approval & Coordination Console       │
+└─────────────────────────────────────────────────────────────┘
+
+ Status Summary:
+   Pending Approvals: 1
+   Total Tasks:       3
+   Daemon URL:        http://127.0.0.1:54321
+   Web Dashboard:     http://127.0.0.1:54321/console
+
+ Pending Approvals Queue:
+   • apr_b12480ad-191a-45c1-92ee-48c68832a820 (message) by architect [2026-09-05T00:30:12.000Z]
+
+ Review pending approvals now? [Y/n]
+```
+
+If pending items exist, pressing <kbd>Enter</kbd> or <kbd>Y</kbd> immediately launches the interactive review session.
+
+---
+
+### B. Interactive Review Loop (`agentcorp review`)
+Run `agentcorp review` (or `agentcorp approvals review`) to step through pending requests one by one:
+
+```sh
+agentcorp review
+```
+
+For each item, you see:
+- Approval ID and subject (`[MESSAGE]` or `[TASK TRANSITION]`).
+- Requesting agent role and target recipient.
+- Formatted context and JSON payload.
+
+#### Keyboard Actions:
+| Key | Action | Description |
+|---|---|---|
+| <kbd>a</kbd> | **Approve** | Signs off immediately. Prompts for an optional reviewer note. |
+| <kbd>e</kbd> | **Edit & Approve** | Prompts for a revised JSON payload. Validates syntax in real time and delivers the modified message to the recipient. |
+| <kbd>r</kbd> | **Reject** | Rejects the request. Prompts for feedback/reason that will be recorded in the audit trail. |
+| <kbd>s</kbd> | **Skip** | Skips the current item without making a decision. |
+| <kbd>q</kbd> | **Quit** | Exits the review session cleanly. |
+
+---
+
+## 2. Real-Time Web Dashboard (`agentcorp console --browser`)
+
+If you prefer a visual interface, launch the dark glassmorphic web dashboard:
+
+```sh
+agentcorp console --browser
+```
+
+### Dashboard Features:
+1. **Live SSE Indicator**: Pulsing connection badge powered by Server-Sent Events (`/api/events`). No polling required.
+2. **Approvals Feed**: Real-time sign-off feed with one-click **Approve**, **Reject**, or **Edit & Approve** with a side-by-side JSON diff editor.
+3. **Role Inboxes**: Inspect messages delivered to each agent's inbox, track read receipts, and view full threads.
+4. **Tasks Kanban**: Live tracking across `open`, `in_progress`, `blocked`, and `completed` states.
+5. **Artifacts Catalog**: Inspect SHA-256 addressed artifacts, metadata, and visibility boundaries.
+6. **Policy Manager**: View all runtime policies and toggle them on/off with instant switches.

package/docs/mcp-tools-reference.md

@@ -0,0 +1,235 @@
+# MCP Tools Reference
+
+AgentCorp exposes 15 coordination tools over the Model Context Protocol (MCP). Every tool call executes within the authenticated role context of the connection, meaning caller identity (`fromRole`, `producedBy`, `callerRole`) is enforced server-side and cannot be spoofed.
+
+---
+
+## 1. Identity & Registration
+
+### `whoami`
+Inspect the bound AgentCorp role and connection identity.
+
+* **Inputs**: None (`{}`)
+* **Returns**:
+  ```json
+  {
+    "role": {
+      "id": "developer",
+      "display_name": "Developer",
+      "model": "any/mcp-capable-agent",
+      "interface": "mcp",
+      "capabilities": ["write_code", "run_tests", "report"],
+      "allowed_peers": ["architect"],
+      "artifact_visibility": ["architect", "developer"]
+    },
+    "agentId": "developer-daemon",
+    "company": "My Agent Company"
+  }
+  ```
+
+### `register_role`
+Optionally bind this role-scoped MCP connection to an agent instance with restricted capabilities. Capabilities may only be reduced, never escalated beyond `org.toml`.
+
+* **Inputs**:
+  * `capabilities` *(array of strings, optional)*: Subscribed capability subset.
+* **Returns**: Updated role definition record.
+
+---
+
+## 2. Task Management
+
+### `create_task`
+Creates a new coordinated task in the broker.
+
+* **Inputs**:
+  * `title` *(string, required)*: Brief summary of the task.
+  * `description` *(string, optional)*: Detailed task requirements, constraints, or acceptance criteria.
+  * `assigned_to` *(string, optional)*: Intended assignee role (must be an allowed peer). The task remains `proposed` and hidden from that role until a linked proposal is approved.
+* **Returns**:
+  ```json
+  {
+    "taskId": "tsk_01h8x...",
+    "title": "Implement auth header hardening",
+    "description": "Enforce Bearer authorization headers and remove query params",
+    "createdBy": "architect",
+    "assignedTo": "developer",
+    "status": "proposed",
+    "createdAt": "2026-09-05T00:00:00.000Z",
+    "updatedAt": "2026-09-05T00:00:00.000Z"
+  }
+  ```
+
+### `list_tasks`
+Lists visible tasks where the caller's role participates. A proposed task is not visible to its intended assignee until an approved proposal activates the assignment.
+
+* **Inputs**:
+  * `limit` *(integer, optional)*: Maximum number of tasks to return (default: `50`, max: `200`).
+  * `cursor` *(string, optional)*: Cursor from a previous page's `nextCursor`.
+  * `envelope` *(boolean, optional)*: If `true`, returns `{ items: [...], nextCursor: string | null }`. If omitted or `false`, returns the array of tasks directly for backward compatibility.
+* **Returns**: Array of `TaskRecord` objects (or paginated envelope if `envelope: true`).
+
+### `get_work_queue`
+Returns the bound role's complete actionable coordination state in one call.
+
+* **Inputs**: None (`{}`)
+* **Returns**: Unread delivered messages, non-terminal visible tasks, summary counts, and prioritized `nextActions`. When an action can be performed directly, `suggestedTool` contains the exact MCP tool name and arguments.
+* **Recommended use**: Call at session start and after every handoff or task-status change instead of separately reconciling the inbox, task list, and threads.
+
+### `update_task_status`
+Transitions a task through its validated lifecycle state graph (`proposed` → `assigned` → `in_progress` → `blocked` / `awaiting_review` → `completed` / `failed` / `cancelled`).
+
+* **Inputs**:
+  * `task_id` *(string, required)*: Task ID to transition.
+  * `new_status` *(string, required)*: Target status (`proposed`, `assigned`, `in_progress`, `blocked`, `awaiting_review`, `completed`, `failed`, `cancelled`).
+  * `risk_tags` *(array of strings, optional)*: Caller-declared risk tags (e.g. `["read_only"]`).
+* **Returns**: Updated `TaskRecord`. If the transition is gated by policy (such as `gate-task-completion`), the transition enters `pending_approval` until approved by a human operator.
+
+---
+
+## 3. Inter-Agent Messaging
+
+### `send_message`
+Submits a typed message through recipient validation and the policy engine.
+
+* **Inputs**:
+  * `to_role` *(string, required)*: Recipient role ID (must be in sender's `allowed_peers`).
+  * `type` *(string, required)*: Message type:
+    * `"proposal"`: Formal plan or change proposal (**strictly held for human approval**).
+    * `"question"`: Inquiry to peer agent.
+    * `"answer"`: Response to inquiry.
+    * `"report"`: Structured execution report.
+    * `"review"`: Architectural or code review.
+    * `"verdict"`: Formal review verdict (`go`, `no_go`, `changes_requested`).
+    * `"status_update"`: Execution milestone update.
+  * `payload` *(unknown / JSON object, required)*: Structured message payload (maximum size: 1 MB by default; exceeds return `PAYLOAD_TOO_LARGE`).
+  * `task_id` *(string, optional)*: Associated task ID.
+  * `references` *(array of strings, optional)*: Referenced artifact IDs or URIs.
+  * `risk_tags` *(array of strings, optional)*: Tags indicating risk category (e.g. `["read_only"]`).
+  * `in_reply_to` *(string, optional)*: ID of the message being answered.
+* **Returns**:
+  ```json
+  {
+    "messageId": "msg_9f2a...",
+    "taskId": "tsk_01h8x...",
+    "fromRole": "architect",
+    "toRole": "developer",
+    "type": "proposal",
+    "payload": { "spec": "0.1.0-alpha.1" },
+    "references": ["art_123..."],
+    "inReplyTo": null,
+    "status": "pending_approval",
+    "riskTags": ["read_only"],
+    "createdAt": "2026-09-05T00:00:00.000Z",
+    "resolvedAt": null
+  }
+  ```
+
+### `get_inbox`
+Retrieves delivered and approved messages addressed to the bound role. Messages held in `pending_approval` are not visible to the recipient until approved.
+
+* **Inputs**:
+  * `limit` *(integer, optional)*: Maximum number of messages to return (default: `50`, max: `200`).
+  * `cursor` *(string, optional)*: Cursor from a previous page's `nextCursor`.
+  * `envelope` *(boolean, optional)*: If `true`, returns `{ items: [...], nextCursor: string | null }`. If omitted or `false`, returns the array directly.
+* **Returns**: Array of unread `MessageRecord` objects with `status: "delivered"` or `"approved"` (or envelope if requested). Acknowledged messages remain in task history but leave the inbox.
+
+### `acknowledge_message`
+Marks a delivered message as acknowledged by its recipient.
+
+* **Inputs**:
+  * `message_id` *(string, required)*: Message ID to acknowledge.
+* **Returns**: Updated `MessageRecord` with `status: "acknowledged"`.
+
+Acknowledgement is idempotent: retrying an already acknowledged message returns its current record.
+
+### `accept_handoff`
+Accepts an approved task proposal using one idempotent coordination operation.
+
+* **Inputs**:
+  * `message_id` *(string, required)*: Delivered proposal message linked to a task assigned to the caller.
+* **Behavior**: Acknowledges the proposal and requests the linked task's `in_progress` transition. If that transition requires human approval, retries reuse the existing pending transition rather than creating duplicate approvals.
+* **Returns**: The acknowledged message, current task, and `pendingApproval` flag.
+
+### `get_thread`
+Retrieves the complete message history for a given task visible to the caller's role.
+
+* **Inputs**:
+  * `task_id` *(string, required)*: Associated task ID.
+  * `limit` *(integer, optional)*: Maximum number of messages to return (default: `50`, max: `200`).
+  * `cursor` *(string, optional)*: Cursor from a previous page's `nextCursor`.
+  * `envelope` *(boolean, optional)*: If `true`, returns `{ items: [...], nextCursor: string | null }`. If omitted or `false`, returns the array directly.
+* **Returns**: Ordered chronological array of `MessageRecord` objects (or envelope if requested).
+
+---
+
+## 4. Artifact Management
+
+### `create_artifact`
+Publishes an immutable, SHA-256 content-addressed artifact with role-based visibility.
+
+* **Inputs**:
+  * `type` *(string, required)*: Artifact type (`spec`, `review`, `resolution`, `code_diff`, `report`).
+  * `name` *(string, required)*: Human-readable display filename.
+  * `content` *(string, optional)*: Inline text content (maximum size: 5 MB by default; exceeds return `ARTIFACT_TOO_LARGE`).
+  * `content_uri` *(string, optional)*: External storage reference (e.g. `file://...` or `s3://...`).
+  * `visible_to_roles` *(array of strings or "all", optional)*: Permitted roles. Defaults to role's `artifact_visibility`.
+  * `related_task_id` *(string, optional)*: Task ID to associate with this artifact.
+* **Returns**:
+  ```json
+  {
+    "artifactId": "art_800eb174...",
+    "type": "review",
+    "name": "agentcorp-architect-release-verdict.md",
+    "producedBy": "architect",
+    "contentHash": "977b4f5325a4c5885de41f...",
+    "visibleToRoles": ["architect", "developer"],
+    "relatedTaskId": "tsk_01h8x...",
+    "createdAt": "2026-09-05T00:00:00.000Z"
+  }
+  ```
+
+### `list_artifacts`
+Lists artifact metadata visible to the caller's role. Content is omitted from list results for performance.
+
+* **Inputs**:
+  * `task_id` *(string, optional)*: Filter by associated task ID.
+  * `limit` *(integer, optional)*: Maximum number of artifacts to return (default: `50`, max: `200`).
+  * `cursor` *(string, optional)*: Cursor from a previous page's `nextCursor`.
+  * `envelope` *(boolean, optional)*: If `true`, returns `{ items: [...], nextCursor: string | null }`. If omitted or `false`, returns the array directly.
+* **Returns**: Array of `ArtifactRecord` metadata objects (or envelope if requested).
+
+### `get_artifact`
+Fetches complete artifact content and metadata after verifying that the caller's role is in the artifact's allowed visibility list.
+
+* **Inputs**:
+  * `artifact_id` *(string, required)*: Artifact ID to retrieve.
+* **Returns**: Complete `ArtifactRecord` including `content` or `contentUri`.
+
+---
+
+## 5. Idempotency & Operation Lookup
+
+### `get_operation`
+Look up a previously executed idempotent operation result by its idempotency key.
+
+* **Inputs**:
+  * `idempotency_key` *(string, required)*: The idempotency key passed during operation execution.
+* **Returns**:
+  ```json
+  {
+    "found": true,
+    "operation": {
+      "key": "create-task-001",
+      "roleId": "developer",
+      "operation": "createTask",
+      "requestHash": "a1b2c3...",
+      "responseJson": "{\"taskId\":\"task_...\"}",
+      "createdAt": "2026-09-05T00:00:00.000Z"
+    }
+  }
+  ```
+
+> [!NOTE]
+> All mutation tools (`create_task`, `send_message`, `accept_handoff`, `create_artifact`, `update_task_status`) accept an optional `idempotency_key` string.
+> Replays with identical keys and request payloads return cached results atomically.
+> Replaying a key with a mismatched operation or mismatched payload raises `IDEMPOTENCY_CONFLICT`.

package/docs/policy-guide.md

@@ -0,0 +1,105 @@
+# Policy & Safety Guide
+
+AgentCorp is designed with a **safe-by-default** governance model. No agent action is auto-approved unless an explicit policy rule permits it.
+
+---
+
+## 1. How Policy Evaluation Works
+
+When an agent requests an action (sending a message or transitioning a task), the broker evaluates active policies:
+
+1. **Descending Priority Order**: Rules with higher `priority` integer values are checked first.
+2. **First Match Wins**: The first policy whose criteria all match dictates the action (`auto_approve` or `require_human`).
+3. **Default Fallback**: If no active rule matches the request, AgentCorp requires human sign-off (`require_human`).
+
+---
+
+## 2. Policy Subjects & Match Criteria
+
+### Subject: `message`
+
+Used to govern inter-agent communication:
+
+| Field | Type | Description |
+|---|---|---|
+| `subject` | `"message"` | Identifies message governance. |
+| `priority` | number | Order of evaluation (e.g. `100`, `50`). |
+| `from_role` | string (optional) | Match only messages from this sender role. |
+| `to_role` | string (optional) | Match only messages to this recipient role. |
+| `message_type` | string (optional) | Match specific types (e.g. `proposal`, `report`, `diff`). |
+| `risk_tags` | string[] (optional) | Subset matching: every tag listed in the policy must be declared on the message. |
+| `action` | `"auto_approve"` \| `"require_human"` | The decision to apply. |
+
+#### Example: Auto-Approve Read-Only Reports
+```toml
+[[policies]]
+id = "allow-read-only-reports"
+subject = "message"
+priority = 100
+risk_tags = ["read_only"]
+action = "auto_approve"
+```
+
+#### Example: Gate Architecture Proposals
+```toml
+[[policies]]
+id = "gate-proposals"
+subject = "message"
+priority = 90
+message_type = "proposal"
+action = "require_human"
+```
+
+---
+
+### Subject: `task`
+
+Used to govern task status lifecycle transitions:
+
+| Field | Type | Description |
+|---|---|---|
+| `subject` | `"task"` | Identifies task transition governance. |
+| `priority` | number | Order of evaluation. |
+| `from_status` | string (optional) | Current status of the task. |
+| `to_status` | string (optional) | Target status being transitioned into (`in_progress`, `completed`, etc.). |
+| `action` | `"auto_approve"` \| `"require_human"` | The decision to apply. |
+
+#### Example: Allow Starting Work
+```toml
+[[policies]]
+id = "allow-start-work"
+subject = "task"
+priority = 80
+to_status = "in_progress"
+action = "auto_approve"
+```
+
+#### Example: Gate Task Completion
+```toml
+[[policies]]
+id = "gate-completion"
+subject = "task"
+priority = 100
+to_status = "completed"
+action = "require_human"
+```
+
+---
+
+## 3. Runtime Policy Management
+
+Policies are initially seeded into SQLite from `org.toml`. After the first run, policies can be dynamically modified at runtime without restarting the daemon:
+
+```sh
+# List all active and disabled policies
+agentcorp policies list
+
+# Disable a policy temporarily
+agentcorp policies disable gate-proposals
+
+# Re-enable a policy
+agentcorp policies enable gate-proposals
+
+# Add a new runtime policy via JSON
+agentcorp policies set '{"id":"allow-diffs","subject":"message","priority":70,"message_type":"diff","action":"auto_approve"}'
+```

package/examples/org.toml

@@ -0,0 +1,65 @@
+[company]
+name = "Example Agent Company"
+
+[limits]
+max_request_body_bytes = 2097152
+max_message_payload_bytes = 1048576
+max_artifact_bytes = 5242880
+default_page_size = 50
+max_page_size = 200
+max_audit_payload_bytes = 65536
+
+[[roles]]
+id = "architect"
+display_name = "Architect"
+model = "openai/codex"
+interface = "mcp"
+capabilities = ["propose_plan", "review", "approve_merge"]
+allowed_peers = ["developer"]
+artifact_visibility = ["architect", "developer"]
+
+[[roles]]
+id = "developer"
+display_name = "Developer"
+model = "any/mcp-capable-agent"
+interface = "mcp"
+capabilities = ["write_code", "run_tests", "report"]
+allowed_peers = ["architect"]
+artifact_visibility = ["architect", "developer"]
+
+[[policies]]
+id = "gate-critical-proposals"
+subject = "message"
+message_type = "proposal"
+priority = 200
+action = "require_human"
+
+[[policies]]
+id = "allow-read-only-status-updates"
+subject = "message"
+message_type = "status_update"
+priority = 100
+risk_tags = ["read_only"]
+action = "auto_approve"
+
+[[policies]]
+id = "allow-read-only-reports"
+subject = "message"
+message_type = "report"
+priority = 100
+risk_tags = ["read_only"]
+action = "auto_approve"
+
+[[policies]]
+id = "allow-start-work"
+subject = "task"
+priority = 50
+to_status = "in_progress"
+action = "auto_approve"
+
+[[policies]]
+id = "gate-task-completion"
+subject = "task"
+priority = 100
+to_status = "completed"
+action = "require_human"

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "agentcorp-broker",
+  "version": "0.1.0-alpha.1",
+  "description": "Local-first MCP coordination broker for teams of AI agents",
+  "type": "module",
+  "license": "Apache-2.0",
+  "author": "AgentCorp contributors",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Shash-J/AgentCorp.git"
+  },
+  "homepage": "https://github.com/Shash-J/AgentCorp#readme",
+  "bugs": {
+    "url": "https://github.com/Shash-J/AgentCorp/issues"
+  },
+  "engines": {
+    "node": ">=22.13.0"
+  },
+  "bin": {
+    "agentcorp": "dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "docs",
+    "!docs/images/**",
+    "!docs/design-spec.md",
+    "examples",
+    "README.md",
+    "CONTRIBUTING.md",
+    "SECURITY.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && node -e \"require('node:fs').cpSync('src/console', 'dist/console', { recursive: true, force: true })\"",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm run check && npm test",
+    "prepack": "npm run build"
+  },
+  "keywords": [
+    "ai-agents",
+    "mcp",
+    "multi-agent",
+    "coordination",
+    "human-in-the-loop",
+    "sqlite"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/client": "^2.0.0",
+    "@modelcontextprotocol/server": "^2.0.0",
+    "commander": "^14.0.0",
+    "smol-toml": "^1.4.2",
+    "zod": "^4.1.5"
+  },
+  "devDependencies": {
+    "@types/node": "^24.3.0",
+    "typescript": "^7.0.2",
+    "vitest": "^3.2.4"
+  }
+}