network-ai 5.13.4 → 5.15.0

package/INTEGRATION_GUIDE.md

@@ -64,7 +64,7 @@ Answers drive `AuthGuardian` configuration and audit log retention policy.
 
 ## 2. Framework Mapping
 
-Network-AI ships 29 adapters. Map your existing agents to the right one:
+Network-AI ships 32 adapters. Map your existing agents to the right one:
 
 | Your Stack | Network-AI Adapter | Notes |
 |-----------|-------------------|-------|
@@ -89,6 +89,9 @@ Network-AI ships 29 adapters. Map your existing agents to the right one:
 | GitHub Copilot | `CopilotAdapter` | Code generate/review/explain/fix/test/refactor/chat |
 | Anthropic Computer Use | `AnthropicComputerUseAdapter` | Screenshot/click/type/scroll browser automation |
 | Google Vertex AI / Gemini | `VertexAIAdapter` | Function calling, multi-modal (text+image) |
+| Google Gemini (Developer API) | `GeminiAdapter` | Gemini 2.5 models, system instructions, thinking budgets (BYOC or `GEMINI_API_KEY`) |
+| OpenAI Responses API | `OpenAIResponsesAdapter` | Assistants successor — reasoning effort, instructions (BYOC or `OPENAI_API_KEY`) |
+| Claude Agent SDK | `ClaudeAgentSDKAdapter` | Full agentic loops (tools, file edits) as swarm agents (BYOC `query`) |
 | Pydantic AI | `PydanticAIAdapter` | Structured output with validation, deps injection |
 | Browser automation | `BrowserAgentAdapter` | Playwright/Puppeteer/CDP browser control |
 | NousResearch Hermes / OpenAI-compatible | `HermesAdapter` | Ollama, Together AI, Fireworks, llama.cpp |
@@ -496,7 +499,7 @@ Run these before declaring the integration production-ready:
 - [ ] `npx ts-node test-phase4.ts` — 147 behavioral tests pass
 - [ ] `npx ts-node test-qa.ts` — 67 QA orchestrator tests pass
 - [ ] `npx ts-node test-phase7.ts` — 94 Phase 7 tests pass (hooks, flow control, composer, semantic search)
-- [ ] `npm run test:all` — all 3,388 tests pass across 38 suites
+- [ ] `npm run test:all` — all 3,603 tests pass across 40 suites
 - [ ] `npm run demo -- --08` runs to completion in < 10 seconds
 
 ### Race Condition Safety
@@ -554,7 +557,7 @@ Run these before declaring the integration production-ready:
 |----------|---------------|
 | [QUICKSTART.md](QUICKSTART.md) | Get running in 5 minutes |
 | [QUICKSTART.md § CLI](QUICKSTART.md) | CLI reference — bb, auth, budget, audit commands |
-| [references/adapter-system.md](references/adapter-system.md) | All 29 adapters with code examples |
+| [references/adapter-system.md](references/adapter-system.md) | All 32 adapters with code examples |
 | [references/trust-levels.md](references/trust-levels.md) | Trust scoring formula and agent roles |
 | [references/auth-guardian.md](references/auth-guardian.md) | Permission system, justification scoring, token lifecycle |
 | [references/blackboard-schema.md](references/blackboard-schema.md) | Blackboard key conventions and namespacing |

package/QUICKSTART.md

@@ -18,7 +18,7 @@ npm install
 npx ts-node setup.ts --check
 ```
 
-**Zero external AI dependencies.** All 29 adapters are self-contained — add framework SDKs only when you need them.
+**Zero external AI dependencies.** All 32 adapters are self-contained — add framework SDKs only when you need them.
 
 ---
 
@@ -49,6 +49,9 @@ npx ts-node setup.ts --check
 | `anthropic-computer-use` | Anthropic Computer Use | `@anthropic-ai/sdk` | Screenshot/click/type/scroll automation |
 | `openai-agents` | OpenAI Agents SDK | `openai` | Tool use, handoffs, guardrails |
 | `vertex-ai` | Vertex AI / Gemini | `@google-cloud/vertexai` | Function calling, multi-modal |
+| `gemini` | Gemini Developer API | none | Google AI Studio models, thinking budgets |
+| `openai-responses` | OpenAI Responses API | none | GPT-5.x / o-series via `/v1/responses` (Assistants successor) |
+| `claude-agent-sdk` | Claude Agent SDK | `@anthropic-ai/claude-agent-sdk` | Full agentic loops as swarm agents |
 | `pydantic-ai` | Pydantic AI | none | Structured output with validation |
 | `browser-agent` | Browser Automation | none | Playwright/Puppeteer/CDP browser control |
 | `hermes` | NousResearch Hermes / OpenAI-compatible | none | Ollama, Together AI, Fireworks, llama.cpp |
@@ -255,7 +258,7 @@ export class MyFrameworkAdapter extends BaseAdapter {
 ```bash
 npx ts-node test-standalone.ts    # 88 core tests
 npx ts-node test-security.ts      # 34 security tests
-npx ts-node test-adapters.ts      # 218 adapter tests (all 29 frameworks)
+npx ts-node test-adapters.ts      # 271 adapter tests (all 32 frameworks)
  npx ts-node test-cli.ts           # 65 CLI tests
 npx ts-node test-qa.ts             # 67 QA orchestrator tests
 ```
@@ -266,7 +269,7 @@ npx ts-node test-qa.ts             # 67 QA orchestrator tests
 
 ```bash
 npx ts-node setup.ts --check      # Verify installation
-npx ts-node setup.ts --list       # List all 29 adapters
+npx ts-node setup.ts --list       # List adapter quick-start snippets
 npx ts-node setup.ts --example    # Generate example.ts
 ```
 
@@ -495,11 +498,13 @@ Your App
             ├── HaystackAdapter     ─── Haystack pipelines
             ├── DSPyAdapter         ─── DSPy modules
             ├── AgnoAdapter         ─── Agno agents/teams
-            ├── AgnoAdapter         ─── Agno agents/teams
             ├── APSAdapter          ─── APS delegation-chain trust
             ├── CopilotAdapter      ─── GitHub Copilot
             ├── LangGraphAdapter    ─── LangGraph state graphs
             ├── VertexAIAdapter     ─── Vertex AI / Gemini
+            ├── GeminiAdapter       ─── Gemini Developer API
+            ├── OpenAIResponsesAdapter ── OpenAI Responses API
+            ├── ClaudeAgentSDKAdapter ─── Claude Agent SDK loops
             ├── PydanticAIAdapter   ─── Pydantic AI structured output
             ├── OpenAIAgentsAdapter ─── OpenAI Agents SDK
             ├── AnthropicComputerUseAdapter ─── Computer Use

package/README.md

@@ -5,10 +5,10 @@
 [![Website](https://img.shields.io/badge/website-network--ai.org-4b9df2?style=flat&logo=web&logoColor=white)](https://network-ai.org/)
 [![CI](https://github.com/Jovancoding/Network-AI/actions/workflows/ci.yml/badge.svg)](https://github.com/Jovancoding/Network-AI/actions/workflows/ci.yml)
 [![CodeQL](https://github.com/Jovancoding/Network-AI/actions/workflows/codeql.yml/badge.svg)](https://github.com/Jovancoding/Network-AI/actions/workflows/codeql.yml)
-[![Release](https://img.shields.io/badge/release-v5.13.4-blue.svg)](https://github.com/Jovancoding/Network-AI/releases)
+[![Release](https://img.shields.io/badge/release-v5.15.0-blue.svg)](https://github.com/Jovancoding/Network-AI/releases)
 [![npm](https://img.shields.io/npm/dw/network-ai.svg?label=npm%20downloads)](https://www.npmjs.com/package/network-ai)
-[![Tests](https://img.shields.io/badge/tests-3388%20passing-brightgreen.svg)](#testing)
-[![Adapters](https://img.shields.io/badge/frameworks-29%20supported-blueviolet.svg)](#adapter-system)
+[![Tests](https://img.shields.io/badge/tests-3603%20passing-brightgreen.svg)](#testing)
+[![Adapters](https://img.shields.io/badge/frameworks-32%20supported-blueviolet.svg)](#adapter-system)
 [![License](https://img.shields.io/badge/license-MIT-brightgreen.svg)](LICENSE)
 [![Socket](https://socket.dev/api/badge/npm/package/network-ai)](https://socket.dev/npm/package/network-ai/overview)
 [![Node.js](https://img.shields.io/badge/node-%3E%3D18.0.0-brightgreen.svg)](https://nodejs.org)
@@ -31,7 +31,8 @@ Network-AI is a TypeScript/Node.js multi-agent orchestrator that adds coordinati
 
 - **Shared blackboard with locking** — atomic `propose → validate → commit` prevents race conditions and split-brain failures across parallel agents
 - **Guardrails and budgets** — FSM governance, per-agent token ceilings, HMAC / Ed25519 audit trails, and permission gating
-- **29 adapters** — LangChain (+ streaming), AutoGen, CrewAI, OpenAI Assistants, LlamaIndex, Semantic Kernel, Haystack, DSPy, Agno, MCP, Custom (+ streaming), OpenClaw, A2A, Codex, MiniMax, NemoClaw, APS, Copilot, LangGraph, Anthropic Computer Use, OpenAI Agents SDK, Vertex AI, Pydantic AI, Browser Agent, Hermes (NousResearch Hermes / any OpenAI-compatible endpoint), Orchestrator (hierarchical multi-orchestrator), and RLM (Recursive Language Model / any RLM-compatible HTTP endpoint) — no glue code, no lock-in
+- **Context signal-over-noise (v5.15)** — `ContextComposer` assembles token-budgeted, relevance-ranked context packs (semantic/lexical × recency decay × scope affinity, position-aware layout); `context_pack` + `blackboard_search` MCP tools let agents pull curated state instead of dumping the whole board into their window
+- **32 adapters** — LangChain (+ streaming), AutoGen, CrewAI, OpenAI Assistants, OpenAI Responses (Assistants successor), LlamaIndex, Semantic Kernel, Haystack, DSPy, Agno, MCP, Custom (+ streaming), OpenClaw, A2A, Codex, MiniMax, NemoClaw, APS, Copilot, LangGraph, Anthropic Computer Use, Claude Agent SDK (agentic loops), OpenAI Agents SDK, Vertex AI, Gemini (Developer API), Pydantic AI, Browser Agent, Hermes (NousResearch Hermes / any OpenAI-compatible endpoint), Orchestrator (hierarchical multi-orchestrator), and RLM (Recursive Language Model / any RLM-compatible HTTP endpoint) — no glue code, no lock-in
 - **Persistent project memory (Layer 3)** — `context_manager.py` injects decisions, goals, stack, milestones, and banned patterns into every system prompt so agents always have full project context
 - **v5.0 modules** — Agent VCR (record/replay), comparison runner, coverage reporter, goal DSL, approval inbox, job queue, gRPC/HTTP transport, playground REPL, adapter test harness, and more
 - **Model-interaction lifecycle governance (v5.13)** — `GovernedModelGateway` absorbs the model refusal → fallback → billing chain (cross-model fallback, fallback-credit repricing, effort governance, thinking-block handoff) behind one governed, budgeted, audited call
@@ -46,6 +47,8 @@ Network-AI is a TypeScript/Node.js multi-agent orchestrator that adds coordinati
 - A **TypeScript/Node.js library** — `import { createSwarmOrchestrator } from 'network-ai'`
 - An **MCP server** — `npx network-ai-server --port 3001`
 - A **CLI** — `network-ai bb get status` / `network-ai audit tail`
+- A **Claude Code plugin** — `/plugin install network-ai@network-ai`
+- A **Gemini CLI extension** — `gemini extensions install https://github.com/Jovancoding/Network-AI`
 - An **OpenClaw skill** — `clawhub install network-ai`
 
 [**5-minute quickstart →**](QUICKSTART.md)  |  [**Architecture →**](ARCHITECTURE.md)  |  [**All adapters →**](#adapter-system)  |  [**Benchmarks →**](BENCHMARKS.md)
@@ -143,7 +146,7 @@ Runs priority preemption, AuthGuardian permission gating, FSM governance, and co
 | ✅ Token budgets | Hard per-agent ceilings with live spend tracking |
 | ✅ Permission gating | HMAC / Ed25519-signed tokens, scoped per agent and resource |
 | ✅ Append-only audit log | Every write, grant, and transition signed and logged |
-| ✅ 29 framework adapters | LangChain, CrewAI, AutoGen, MCP, Codex, APS, RLM, and 22 more — zero lock-in |
+| ✅ 32 framework adapters | LangChain, CrewAI, AutoGen, MCP, Codex, Gemini, APS, RLM, and 24 more — zero lock-in |
 | ✅ FSM governance | Hard-stop agents at state boundaries, timeout enforcement |
 | ✅ Compliance monitoring | Real-time violation detection (tool abuse, turn-taking, timeouts) |
 | ✅ Claim verification | Tier 1 agent honesty — outcome-bound signed receipts, manifest reconciliation, trust decay for liars |
@@ -193,7 +196,7 @@ Runs priority preemption, AuthGuardian permission gating, FSM governance, and co
 | Race conditions in parallel agents | Atomic blackboard: `propose → validate → commit` with file-system mutex |
 | Agent overspend / runaway costs | `FederatedBudget` — hard per-agent token ceilings with live spend tracking |
 | No visibility into what agents did | HMAC / Ed25519-signed audit log on every write, permission grant, and FSM transition |
-| Locked into one AI framework | 29 adapters — mix LangChain + AutoGen + CrewAI + Codex + MiniMax + NemoClaw + APS + LangGraph + Vertex AI + Hermes + RLM + custom in one swarm |
+| Locked into one AI framework | 32 adapters — mix LangChain + AutoGen + CrewAI + Codex + Gemini + MiniMax + NemoClaw + APS + LangGraph + Vertex AI + Hermes + RLM + custom in one swarm |
 | Agents escalating beyond their scope | `AuthGuardian` — scoped permission tokens required before sensitive operations |
 | Agents lack project context between runs | `ProjectContextManager` (Layer 3) — inject decisions, goals, stack, and milestones into every system prompt |
 | No regression tracking on agent output quality | `QAOrchestratorAgent` — scenario replay, feedback loops, cross-agent contradiction detection, historical trend tracking |
@@ -297,6 +300,8 @@ curl http://localhost:3001/tools    # full tool list
 
 **Tools exposed over MCP:**
 - `blackboard_read` / `blackboard_write` / `blackboard_list` / `blackboard_delete` / `blackboard_exists`
+- `context_pack` — token-budgeted, relevance-ranked context brief for a task (use instead of dumping the whole board into your window)
+- `blackboard_search` — ranked top-K search over blackboard entries (semantic when an embedder is wired, lexical otherwise)
 - `budget_status` / `budget_spend` / `budget_reset` — federated token tracking
 - `token_create` / `token_validate` / `token_revoke` — HMAC / Ed25519-signed permission tokens
 - `audit_query` — query the append-only audit log
@@ -330,9 +335,27 @@ The repo root carries the standard plugin layout:
 | [`.claude-plugin/plugin.json`](.claude-plugin/plugin.json) | Plugin manifest |
 | [`.mcp.json`](.mcp.json) | Registers the Network-AI MCP server (stdio) |
 | [`.claude-plugin/marketplace.json`](.claude-plugin/marketplace.json) | Self-hosted marketplace catalog |
+| [`commands/`](commands/status.md) | Slash commands — `/network-ai:status`, `/network-ai:budget`, `/network-ai:audit`, `/network-ai:blackboard` |
 
 Validate the manifests locally with `claude plugin validate .`.
 
+**Gate Claude Code itself with AuthGuardian (hooks).** Every tool call Claude Code makes — shell commands, file edits, web fetches — can be audited and permission-gated through the same weighted scoring (justification 40%, trust 30%, risk 30%) Network-AI applies to swarm agents:
+
+```jsonc
+// .claude/settings.json — see examples/claude-code-hooks.json for the full config
+{
+  "hooks": {
+    "PreToolUse": [{
+      "matcher": "Bash|Write|Edit|WebFetch",
+      "hooks": [{ "type": "command",
+                  "command": "npx -y -p network-ai network-ai hook pre-tool-use --mode enforce" }]
+    }]
+  }
+}
+```
+
+`--mode observe` (default) audits every call to `data/hooks_audit.jsonl` without blocking; `--mode enforce` maps tools to resource types (Bash → `SHELL_EXEC`, Write/Edit → `FILE_SYSTEM`, WebFetch → `EXTERNAL_SERVICE`) and requires an AuthGuardian grant — denied calls escalate to you as an interactive prompt. `--deny "rm -rf"` patterns hard-block regardless of mode.
+
 ---
 
 ## Use with OpenAI Codex
@@ -359,6 +382,35 @@ Either route exposes the full tool set (`blackboard_read`, `budget_status`, `aud
 
 ---
 
+## Use with Gemini CLI
+
+Network-AI ships as a [Gemini CLI](https://github.com/google-gemini/gemini-cli) extension — the repo root carries [`gemini-extension.json`](gemini-extension.json), which wires in the stdio MCP server and a [`GEMINI.md`](GEMINI.md) context file automatically:
+
+```bash
+gemini extensions install https://github.com/Jovancoding/Network-AI
+```
+
+Or register just the MCP server directly:
+
+```bash
+gemini mcp add network-ai npx -- -y -p network-ai network-ai-server --stdio
+```
+
+Run `/mcp` inside Gemini CLI to confirm the `network-ai` tools are loaded. For building Gemini-powered swarm agents, use the `GeminiAdapter` (Gemini Developer API / AI Studio) or `VertexAIAdapter` (Vertex AI on GCP) — and for Google's Agent2Agent ecosystem, `A2AServer` exposes this orchestrator as a discoverable A2A agent:
+
+```typescript
+import { A2AServer } from 'network-ai';
+
+const a2a = new A2AServer({
+  name: 'Network-AI Orchestrator',
+  secret: process.env.A2A_SECRET,
+  executor: async (text) => ({ text: await runSwarmTask(text) }),
+});
+a2a.startServer(4310); // serves /.well-known/agent.json + tasks/send
+```
+
+---
+
 ## CLI
 
 Control Network-AI directly from the terminal — no server required. The CLI imports the same core engine used by the MCP server.
@@ -467,7 +519,7 @@ npx ts-node examples/10-nemoclaw-sandbox-swarm.ts
 
 ## Adapter System
 
-29 adapters, zero adapter dependencies. You bring your own SDK objects.
+32 adapters, zero adapter dependencies. You bring your own SDK objects.
 
 | Adapter | Framework / Protocol | Register method |
 |---|---|---|
@@ -532,7 +584,7 @@ Extend `BaseAdapter` (or `StreamingBaseAdapter` for streaming) to add your own i
 npm run test:all          # All suites in sequence
 npm test                  # Core orchestrator
 npm run test:security     # Security module
-npm run test:adapters     # All 29 adapters
+npm run test:adapters     # All 32 adapters
 npm run test:streaming    # Streaming adapters
 npm run test:a2a          # A2A protocol adapter
 npm run test:codex        # Codex adapter
@@ -542,15 +594,15 @@ npm run test:phase9       # Agent runtime, console, strategy agent
 npm run test:phase12      # Context Throttler, Partition Planner, Coverage Gate, Route Classifier
 ```
 
-**3,388 passing assertions across 38 test suites** (`npm run test:all`):
+**3,603 passing assertions across 40 test suites** (`npm run test:all`):
 
 | Suite | Assertions | Covers |
 |---|---|---|
 | `test-phase4.ts` | 147 | FSM governance, compliance monitor, adapter integration |
 | `test-phase5f.ts` | 127 | SSE transport, `McpCombinedBridge`, extended MCP tools |
 | `test-phase5g.ts` | 121 | CRDT backend, vector clocks, bidirectional sync |
-| `test-phase6.ts` | 121 | MCP server, control-plane tools, audit tools |
-| `test-adapters.ts` | 218 | All 29 adapters, registry routing, integration, edge cases |
+| `test-phase6.ts` | 129 | MCP server, control-plane tools, audit tools |
+| `test-adapters.ts` | 271 | All 32 adapters, registry routing, integration, edge cases |
 | `test-phase5d.ts` | 117 | Pluggable backend (Redis, CRDT, Memory) |
 | `test-standalone.ts` | 88 | Blackboard, auth, integration, persistence, parallelisation, quality gate |
 | `test-phase5e.ts` | 87 | Federated budget tracking |
@@ -568,9 +620,9 @@ npm run test:phase12      # Context Throttler, Partition Planner, Coverage Gate,
 | `test-qa.ts` | 67 | QA orchestrator: scenarios, feedback loop, regression, contradictions |
 | `test-phase7.ts` | 94 | Deferred init, hook middleware, flow control, skill composer, semantic search |
 | `test-phase8.ts` | 146 | Phase pipeline, confidence filter, matcher-based hooks, fan-out/fan-in |
-| `test-phase9.ts` | 280 | Agent runtime, sandbox policy, shell executor, file accessor, approval gate, console UI, orchestrator wiring, pipe mode, strategy agent |
+| `test-phase9.ts` | 293 | Agent runtime, sandbox policy, shell executor, file accessor, approval gate, console UI, orchestrator wiring, pipe mode, strategy agent |
 | `test-phase10.ts` | 153 | Goal decomposer, task DAG validation, topological layers, JSON parsing, team runner, concurrency, timeouts, events, runTeam one-liner, dependency injection, LLM planner |
-| `test-phase11.ts` | 43 | TTL background sweep, WAL crash recovery, CircuitBreaker, `ITelemetryProvider` / OTel hooks |
+| `test-phase11.ts` | 55 | TTL background sweep, WAL crash recovery, CircuitBreaker, `ITelemetryProvider` / OTel hooks |
 | `test-topology.ts` | 304 | WorkTree, ControlPlane, dashboard server, topology visualization, WebSocket protocol |
 | `test-rlm-phases.ts` | 123 | FederatedBudget child spending, blackboard metadata API, best-partial result, HookContext depth, sub-goal recursion, semaphore fan-out, PhasePipeline compaction, RLMAdapter end-to-end |
 | `test-phase12.ts` | 65 | Context Throttler, Partition Planner, Coverage Gate, Route Classifier, EVALUATING FSM state, runTeam integration |
@@ -582,6 +634,8 @@ npm run test:phase12      # Context Throttler, Partition Planner, Coverage Gate,
 | `test-phase15.ts` | 32 | Orchestration resilience: `RetryBudget`, per-sub-agent fallback in `FanOutFanIn` + `TeamRunner`, `EffortPolicy` |
 | `test-phase16.ts` | 21 | `ThinkingBlockManager` lifecycle + reasoning-extraction guard, OWASP Agentic Top 10 coverage matrix |
 | `test-phase17.ts` | 13 | `ApprovalInbox` GHSA-m4jg-6w3q-gm86 fix: read-route auth gating, token validation, backward compatibility, CORS allowlist |
+| `test-phase18.ts` | 85 | `ClaudeHookBridge` observe/enforce gating, MCP elicitation channel + fail-closed approval callback, `A2AServer` agent card / tasks / auth / eviction |
+| `test-phase19.ts` | 78 | `ContextComposer` ranking/budget/pinning/staleness/layout, `estimateTokens`, `context_pack` + `blackboard_search` MCP tools (lexical + semantic modes) |
 | `test.ts` | 39 | Core orchestrator smoke tests |
 
 ---
@@ -600,9 +654,10 @@ npm run test:phase12      # Context Throttler, Partition Planner, Coverage Gate,
 | [ENTERPRISE.md](ENTERPRISE.md) | Evaluation checklist, stability policy, security summary, integration entry points |
 | [AUDIT_LOG_SCHEMA.md](AUDIT_LOG_SCHEMA.md) | Audit log field reference, all event types (including `model.refusal` / `model.attempt`), scoring formula |
 | [ADOPTERS.md](ADOPTERS.md) | Known adopters — open a PR to add yourself |
-| [INTEGRATION_GUIDE.md](INTEGRATION_GUIDE.md) | End-to-end integration walkthrough with v5.13 modules |
+| [INTEGRATION_GUIDE.md](INTEGRATION_GUIDE.md) | End-to-end integration walkthrough with v5.15 modules |
 | [SKILL.md](SKILL.md) | OpenClaw/ClawHub Python skill — setup, orchestrator protocol, OWASP engine coverage, security scan findings |
-| [references/adapter-system.md](references/adapter-system.md) | Adapter architecture, all 29 adapters (incl. `AnthropicMessagesAdapter`), writing custom adapters |
+| [AGENTS.md](AGENTS.md) | Cross-vendor agent instructions (Codex, Gemini CLI, Cursor, Factory) — build commands, conventions, architecture patterns |
+| [references/adapter-system.md](references/adapter-system.md) | Adapter architecture, all 32 adapters (incl. `AnthropicMessagesAdapter`), writing custom adapters |
 | [references/auth-guardian.md](references/auth-guardian.md) | Permission scoring, resource types, `scoreRequest()`, IAuthValidator interface |
 | [references/trust-levels.md](references/trust-levels.md) | Trust level configuration, APS delegation-chain mapping |
 
@@ -613,6 +668,8 @@ npm run test:phase12      # Context Throttler, Partition Planner, Coverage Gate,
 > Using **Claude Code** (the CLI)? See [Use as a Claude Code Plugin](#use-as-a-claude-code-plugin) — one command installs every tool.
 >
 > Using **OpenAI Codex** (CLI or IDE)? See [Use with OpenAI Codex](#use-with-openai-codex) — add the MCP server with a single `codex mcp add`.
+>
+> Using **Gemini CLI**? See [Use with Gemini CLI](#use-with-gemini-cli) — install the extension with a single `gemini extensions install`.
 
 Three integration files are included in the repo root:
 

package/SKILL.md

@@ -767,7 +767,7 @@ The following findings are drawn from the **MAESTRO Agent Security Threat** fram
 
 | Control | How Network-AI addresses it |
 |---|---|
-| **Exact version pinning** | npm `package.json` uses exact `"version": "5.13.4"` — no semver range specifiers; `clawhub install network-ai` pins to a specific published version |
+| **Exact version pinning** | npm `package.json` uses exact `"version": "5.15.0"` — no semver range specifiers; `clawhub install network-ai` pins to a specific published version |
 | **Zero transitive dependency drift** | All bundled Python scripts use Python stdlib only — `pip install` is never required; there are no third-party packages to drift, be compromised upstream, or introduce CVEs |
 | **Signed, tagged releases** | Every release is committed with a signed Git tag (`v5.7.x`); commit hash is verifiable against CHANGELOG.md; GitHub releases link tag → diff → changelog entry |
 | **Supply chain monitoring** | npm package continuously scored by Socket.dev (score A); any new dependency or permission change triggers an alert |

package/bin/cli.ts

@@ -17,6 +17,7 @@ import { LockedBlackboard } from '../lib/locked-blackboard';
 import { AuthGuardian } from '../index';
 import { FederatedBudget } from '../lib/federated-budget';
 import { EnvironmentManager } from '../lib/env-manager';
+import { ClaudeHookBridge } from '../lib/claude-hooks';
 
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const pkg = (() => {
@@ -695,6 +696,78 @@ program.command('inspect <key>')
     }
   });
 
+// ── hook (coding-agent hooks bridge) ──────────────────────────────────────────
+
+function readStdinFully(): Promise<string> {
+  return new Promise((resolvePromise, rejectPromise) => {
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk: string) => { data += chunk; });
+    process.stdin.on('end', () => resolvePromise(data));
+    process.stdin.on('error', rejectPromise);
+  });
+}
+
+const hookCmd = program.command('hook')
+  .description('Coding-agent hook bridge — audit/gate tool calls through AuthGuardian (Claude Code PreToolUse/PostToolUse)');
+
+hookCmd.command('pre-tool-use')
+  .description('Handle a PreToolUse hook event: reads hook JSON from stdin, writes a permission decision to stdout')
+  .option('--mode <mode>', "'observe' (audit only) or 'enforce' (AuthGuardian-gated)", process.env['NETWORK_AI_HOOKS_MODE'] ?? 'observe')
+  .option('--agent <id>', 'agent identity for permission requests', 'claude-code')
+  .option('--trust <level>', 'trust level for the agent identity (0-1)', (v: string) => parseFloat(v), 0.7)
+  .option('--deny <pattern...>', 'regex pattern(s) — matching tool calls are denied outright')
+  .option('--allow <pattern...>', 'regex pattern(s) — matching tool calls are allowed without gating')
+  .option('--blocked-decision <decision>', "decision when the guardian denies: 'ask' (escalate to human) or 'deny'", 'ask')
+  .action(async (opts: { mode: string; agent: string; trust: number; deny?: string[]; allow?: string[]; blockedDecision: string }, cmd: Command) => {
+    const g = cmd.optsWithGlobals<{ data: string; json: boolean }>();
+    if (opts.mode !== 'observe' && opts.mode !== 'enforce') die(`invalid --mode: ${opts.mode} (use observe|enforce)`);
+    if (opts.blockedDecision !== 'ask' && opts.blockedDecision !== 'deny') die(`invalid --blocked-decision: ${opts.blockedDecision} (use ask|deny)`);
+    const dataDir = resolveData(g);
+    const bridge = new ClaudeHookBridge({
+      mode: opts.mode,
+      agentId: opts.agent,
+      trustLevel: opts.trust,
+      denyPatterns: opts.deny,
+      allowPatterns: opts.allow,
+      blockedDecision: opts.blockedDecision,
+      auditLogPath: path.join(dataDir, 'hooks_audit.jsonl'),
+      guardianAuditLogPath: path.join(dataDir, 'audit_log.jsonl'),
+      trustConfigPath: path.join(dataDir, 'trust_levels.json'),
+    });
+    try {
+      const raw = await readStdinFully();
+      const input = ClaudeHookBridge.parseInput(raw);
+      const out = await bridge.handlePreToolUse(input);
+      process.stdout.write(JSON.stringify(out) + '\n');
+    } catch (err) {
+      process.stderr.write(`network-ai hook: ${err instanceof Error ? err.message : String(err)}\n`);
+      process.exit(1);
+    }
+  });
+
+hookCmd.command('post-tool-use')
+  .description('Handle a PostToolUse hook event: reads hook JSON from stdin, appends an audit entry')
+  .option('--agent <id>', 'agent identity recorded in the audit trail', 'claude-code')
+  .action(async (opts: { agent: string }, cmd: Command) => {
+    const g = cmd.optsWithGlobals<{ data: string; json: boolean }>();
+    const dataDir = resolveData(g);
+    const bridge = new ClaudeHookBridge({
+      mode: 'observe',
+      agentId: opts.agent,
+      auditLogPath: path.join(dataDir, 'hooks_audit.jsonl'),
+    });
+    try {
+      const raw = await readStdinFully();
+      const input = ClaudeHookBridge.parseInput(raw);
+      const out = await bridge.handlePostToolUse(input);
+      process.stdout.write(JSON.stringify(out) + '\n');
+    } catch (err) {
+      process.stderr.write(`network-ai hook: ${err instanceof Error ? err.message : String(err)}\n`);
+      process.exit(1);
+    }
+  });
+
 // ── pause / resume (kill switch) ──────────────────────────────────────────────
 
 program.command('pause')

package/bin/mcp-server.ts

@@ -48,6 +48,7 @@ import {
 import type { McpJsonRpcRequest } from '../lib/mcp-bridge';
 import { ExtendedMcpTools } from '../lib/mcp-tools-extended';
 import { ControlMcpTools } from '../lib/mcp-tools-control';
+import { ContextMcpTools } from '../lib/mcp-tools-context';
 
 // ============================================================================
 // ARGUMENT PARSING
@@ -157,6 +158,14 @@ SSE/HTTP mode (for network clients):
  */
 async function runStdio(combined: McpCombinedBridge): Promise<void> {
   const { createInterface } = await import('readline');
+  const { StdioElicitationChannel } = await import('../lib/mcp-elicitation');
+
+  // Server→client request channel (MCP elicitation). Client responses to
+  // server-initiated requests are routed here instead of being dispatched
+  // (incorrectly) as client requests.
+  const elicitation = new StdioElicitationChannel((line: string) => {
+    process.stdout.write(line + '\n');
+  });
 
   const rl = createInterface({ input: process.stdin, terminal: false });
 
@@ -178,11 +187,17 @@ async function runStdio(combined: McpCombinedBridge): Promise<void> {
       return;
     }
 
+    // Response to a server-initiated request (elicitation)? Consume it.
+    if (elicitation.handleMessage(request)) return;
+
     const response = await combined.handleRPC(request);
     process.stdout.write(JSON.stringify(response) + '\n');
   });
 
-  rl.on('close', () => process.exit(0));
+  rl.on('close', () => {
+    elicitation.rejectAll('stdin closed');
+    process.exit(0);
+  });
 }
 
 // ============================================================================
@@ -286,6 +301,14 @@ async function main(): Promise<void> {
   if (extendedTools) combined.register(extendedTools);
   if (controlTools) combined.register(controlTools);
 
+  // Context tools: token-budgeted context packs + ranked blackboard search
+  // (lexical ranking out of the box; embed a SemanticMemory for semantic mode)
+  const contextTools = new ContextMcpTools({
+    blackboard: blackboard as unknown as import('../lib/mcp-blackboard-tools').IBlackboard,
+  });
+  combined.register(contextTools);
+  console.log(`[network-ai-server] Context tools: context_pack, blackboard_search (lexical mode)`);
+
   const totalTools = combined.allDefinitions().length;
   console.log(`[network-ai-server] Total tools exposed: ${totalTools}`);
 

package/dist/adapters/claude-agent-sdk-adapter.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Claude Agent SDK Adapter
+ *
+ * Integrates agents built with Anthropic's Claude Agent SDK
+ * (`@anthropic-ai/claude-agent-sdk`) with the SwarmOrchestrator. The SDK's
+ * `query()` function runs a full agentic loop (tool use, file edits, shell)
+ * and streams SDK messages; this adapter drives that loop and returns the
+ * final result to the swarm.
+ *
+ * Strictly BYOC: the SDK is never imported here. Callers pass the SDK's
+ * `query` function (or any compatible implementation) at registration time.
+ *
+ * Usage:
+ *   import { query } from '@anthropic-ai/claude-agent-sdk';
+ *
+ *   const adapter = new ClaudeAgentSDKAdapter();
+ *   await adapter.initialize({});
+ *   adapter.registerAgent('coder', {
+ *     query,                                  // the SDK's query function
+ *     options: { maxTurns: 10, allowedTools: ['Read', 'Grep'] },
+ *     systemPrompt: 'You are a careful refactoring agent.',
+ *   });
+ *
+ *   await registry.addAdapter(adapter);
+ *   // orchestrator: delegateTask({ targetAgent: 'claude-agent-sdk:coder', ... })
+ *
+ * @module ClaudeAgentSDKAdapter
+ * @version 1.0.0
+ */
+import { BaseAdapter } from './base-adapter';
+import type { AdapterCapabilities, AgentPayload, AgentContext, AgentResult } from '../types/agent-adapter';
+/**
+ * A message yielded by the Claude Agent SDK's query loop. Only the fields
+ * this adapter consumes are modeled; extra fields pass through untouched.
+ */
+export interface ClaudeSDKMessage {
+    /** Message kind — 'assistant', 'user', 'system', 'result', ... */
+    type: string;
+    /** For result messages: 'success' or an error subtype */
+    subtype?: string;
+    /** For result messages: the final result text */
+    result?: string;
+    /** Total cost in USD, when reported */
+    total_cost_usd?: number;
+    /** Number of agentic turns taken */
+    num_turns?: number;
+    /** Session identifier assigned by the SDK */
+    session_id?: string;
+    /** Token usage, when reported */
+    usage?: Record<string, unknown>;
+    /** Whether the run ended in an error */
+    is_error?: boolean;
+}
+/**
+ * The Claude Agent SDK `query` function shape. Matches
+ * `@anthropic-ai/claude-agent-sdk`'s `query({ prompt, options })`, which
+ * returns an async iterable of SDK messages.
+ */
+export type ClaudeAgentQueryFn = (params: {
+    prompt: string;
+    options?: Record<string, unknown>;
+}) => AsyncIterable<ClaudeSDKMessage>;
+/** Configuration for a registered Claude Agent SDK agent */
+export interface ClaudeAgentSDKConfig {
+    /** The SDK's query function (BYOC — required) */
+    query: ClaudeAgentQueryFn;
+    /**
+     * Options forwarded to the SDK on every run — e.g. `maxTurns`,
+     * `allowedTools`, `permissionMode`, `cwd`, `model`.
+     */
+    options?: Record<string, unknown>;
+    /** System prompt override — forwarded as `options.systemPrompt` */
+    systemPrompt?: string;
+    /**
+     * Called for every intermediate SDK message (assistant turns, tool use)
+     * before the final result — useful for progress reporting.
+     */
+    onMessage?: (message: ClaudeSDKMessage) => void;
+}
+/**
+ * Adapter that runs Claude Agent SDK agentic loops as swarm agents.
+ * The final `result` message becomes the AgentResult; intermediate messages
+ * are surfaced through the per-agent `onMessage` callback.
+ */
+export declare class ClaudeAgentSDKAdapter extends BaseAdapter {
+    readonly name = "claude-agent-sdk";
+    readonly version = "1.0.0";
+    private agents;
+    get capabilities(): AdapterCapabilities;
+    /**
+     * Register a Claude Agent SDK-powered agent.
+     *
+     * @param agentId   Unique identifier used in `delegateTask` calls.
+     * @param config    Agent configuration — `query` is required.
+     */
+    registerAgent(agentId: string, config: ClaudeAgentSDKConfig): void;
+    executeAgent(agentId: string, payload: AgentPayload, context: AgentContext): Promise<AgentResult>;
+    shutdown(): Promise<void>;
+}
+//# sourceMappingURL=claude-agent-sdk-adapter.d.ts.map

package/dist/adapters/claude-agent-sdk-adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-agent-sdk-adapter.d.ts","sourceRoot":"","sources":["../../adapters/claude-agent-sdk-adapter.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,KAAK,EACV,mBAAmB,EACnB,YAAY,EACZ,YAAY,EACZ,WAAW,EACZ,MAAM,wBAAwB,CAAC;AAMhC;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,kEAAkE;IAClE,IAAI,EAAE,MAAM,CAAC;IACb,yDAAyD;IACzD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iDAAiD;IACjD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,uCAAuC;IACvC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,oCAAoC;IACpC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,6CAA6C;IAC7C,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,iCAAiC;IACjC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC,wCAAwC;IACxC,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AAED;;;;GAIG;AACH,MAAM,MAAM,kBAAkB,GAAG,CAAC,MAAM,EAAE;IACxC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC,KAAK,aAAa,CAAC,gBAAgB,CAAC,CAAC;AAEtC,4DAA4D;AAC5D,MAAM,WAAW,oBAAoB;IACnC,iDAAiD;IACjD,KAAK,EAAE,kBAAkB,CAAC;IAC1B;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,mEAAmE;IACnE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,gBAAgB,KAAK,IAAI,CAAC;CACjD;AAuCD;;;;GAIG;AACH,qBAAa,qBAAsB,SAAQ,WAAW;IACpD,QAAQ,CAAC,IAAI,sBAAsB;IACnC,QAAQ,CAAC,OAAO,WAAW;IAE3B,OAAO,CAAC,MAAM,CAA4C;IAE1D,IAAI,YAAY,IAAI,mBAAmB,CAStC;IAMD;;;;;OAKG;IACH,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,oBAAoB,GAAG,IAAI;IA6B5D,YAAY,CAChB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,YAAY,EACrB,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC,WAAW,CAAC;IA8FjB,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;CAIhC"}