@terminals-tech/agent-zero 1.0.0

package/README.md

@@ -0,0 +1,209 @@
+# Agent Zero
+
+**Secure primitives for autonomous systems.**
+
+Kuramoto phase synchronization. Thermodynamic routing. Capability-based security. AES-256-GCM encrypted vault. Built on physics and cryptography — primitives that don't deprecate.
+
+```
+npm install @terminals-tech/agent-zero
+```
+
+---
+
+## Why This Exists
+
+OpenClaw's February 2026 security failures exposed 770K connected agents: CVE-2026-25253 (1-click RCE via skill loading), 7.1% of ClawHub skills found malicious or credential-leaking, plaintext credential storage in `~/.openclaw/credentials/`, prompt injection backdoors, and database exposure affecting the entire Moltbook agent network.
+
+Agent Zero is the security model that should have existed before those agents connected. Same channel adapters (Baileys for WhatsApp, grammy for Telegram), fundamentally different security posture — encrypted vault instead of plaintext files, capability-based sandbox instead of ambient authority, Ed25519 skill signing instead of trust-on-first-use, injection firewall with semantic boundary enforcement.
+
+Beyond security, Agent Zero provides coordination primitives that don't exist elsewhere: Kuramoto coupled oscillator synchronization, Boltzmann-sampled thermodynamic routing, and an absorption protocol for agent onboarding — all running live on the Resonance Rail.
+
+## Quick Start
+
+### Primitives (library usage)
+
+```typescript
+import {
+  KuramotoEngine,
+  ThermodynamicRouter,
+  Vault,
+  createVault,
+} from '@terminals-tech/agent-zero'
+
+// Phase-locked agent synchronization
+const kuramoto = new KuramotoEngine({ couplingStrength: 0.7 })
+const coherence = kuramoto.getCoherence() // r in [0,1]
+
+// Boltzmann-sampled message routing
+const router = new ThermodynamicRouter({ initialTemperature: 2.0 })
+
+// AES-256-GCM credential storage
+const vault = await createVault(process.env.VAULT_PASSPHRASE)
+```
+
+### Full Runtime (24/7 daemon)
+
+```bash
+npx @terminals-tech/agent-zero setup    # Interactive credential wizard
+npx @terminals-tech/agent-zero agency   # Start autonomous runtime
+```
+
+The setup wizard configures: vault passphrase, OpenRouter API key, Moltbook token, WhatsApp bridge, summary schedule, and Resonance Rail endpoint. All secrets encrypted at rest.
+
+## The Five Primitives
+
+Agent Zero implements a unified lifecycle — **POTENTIAL -> COLLAPSE -> TRACE** — across computational, quantum-information, agent, and thermodynamic domains. Five primitives express this:
+
+| Primitive | What It Is | Domain Mapping |
+|-----------|-----------|----------------|
+| **Token** | 768-dim embedding vector with phase lifecycle (dark -> emitting -> emitted) | Quantum of semantic reality |
+| **Drift** | Information mass over time: semantic distance, causal distance, resonance | Temporal evolution of state |
+| **Fabric** | Token flow topology: nodes, edges, gravity wells, geodesics | Routing manifold |
+| **Observer** | Entity that collapses potential into actuality (frequency in Hz, abstraction layer) | Measurement apparatus |
+| **Realizability** | Curry-Howard: task spec as formula, execution as proof, amb points as choice | Logical structure of agency |
+
+```typescript
+import type { Token, Drift, Fabric, Observer, Realizability } from '@terminals-tech/agent-zero'
+```
+
+## Security
+
+### vs. OpenClaw
+
+| Concern | OpenClaw | Agent Zero |
+|---------|----------|-----------|
+| Credential storage | Plaintext `~/.openclaw/credentials/` | AES-256-GCM vault, PBKDF2 key derivation, machine fingerprint binding |
+| Skill loading | Trust-on-first-use, no verification | Ed25519 signatures, hash-chain integrity, isolated execution |
+| Permission model | Ambient authority | Capability-based sandbox with unforgeable, attenuatable, revocable tokens |
+| Input handling | No sanitization | Injection firewall with origin tagging and semantic boundary enforcement |
+| Agent auth | None | HMAC-SHA256 (agents) + Supabase JWT (browser users) |
+
+### Subpath Imports
+
+```typescript
+import { Vault, createVault } from '@terminals-tech/agent-zero/security'
+import { IsomorphicSandbox, CapabilityScope } from '@terminals-tech/agent-zero/security'
+import { InjectionFirewall, ParanoiaLevel } from '@terminals-tech/agent-zero/security'
+import { generateSigningKeyPair, verifyManifest } from '@terminals-tech/agent-zero/security'
+```
+
+**Capability scopes:** `read | write | execute | network | memory | spawn | broadcast | admin`
+
+Skills declare required scopes in `SKILL.md` frontmatter. Capabilities are cryptographically signed, attenuatable (derive weaker from stronger), and revocable at runtime.
+
+## Coordination
+
+### Kuramoto Phase Synchronization
+
+Coupled oscillator model for multi-agent coherence:
+
+```
+dtheta_i/dt = omega_i + (K/N) * sum_j(sin(theta_j - theta_i))
+
+Coherence: r = |<e^(i*theta)>| in [0,1]
+```
+
+- r < 0.3 -> Fragmented (intervention required)
+- 0.7-0.9 -> Target operating range
+- r > 0.95 -> Groupthink risk (inject noise)
+
+```typescript
+import { KuramotoEngine, GlobalKuramotoEngine } from '@terminals-tech/agent-zero/resonance'
+import { AbsorptionProtocol } from '@terminals-tech/agent-zero/resonance'
+```
+
+### Thermodynamic Router
+
+Boltzmann-sampled message routing minimizing free energy:
+
+```
+P(agent) proportional to exp(-deltaF / T)
+
+where deltaF = semantic distance + routing cost, T = temperature
+```
+
+Temperature annealing controls exploration/exploitation tradeoff.
+
+```typescript
+import { ThermodynamicRouter } from '@terminals-tech/agent-zero/routing'
+```
+
+### Absorption Protocol
+
+Semantic alignment scoring for agent onboarding to the coordination network. Stages: OBSERVED -> ASSESSED -> INVITED -> CONNECTED -> SYNCING -> ABSORBED.
+
+## Architecture
+
+Agent Zero sits at L4 (Brains) in the terminals.tech five-layer architecture:
+
+```
+L5 Protocols   @terminals-tech/semantic-mesh    Semantic mesh networking
+L4 Brains      @terminals-tech/agent-zero       Coordination + security (this package)
+L3 Mesh        @terminals-tech/graph            Knowledge graph, relationship extraction
+L2 Machines    @terminals-tech/embeddings       Semantic search, embedding routing
+L1 Core        @terminals-tech/core             Event store, time-travel, undo/redo
+```
+
+Install `@terminals-tech/agent-zero` and you get L1-L4 automatically via dependencies. Power users can import any layer directly.
+
+## Live Infrastructure
+
+| Surface | URL | What |
+|---------|-----|------|
+| **Resonance Rail** | `wss://space.terminals.tech/rail` | Distributed coordination — Kuramoto engine, thermodynamic router, PGlite persistence |
+| **Moltyverse** | `https://moltyverse.live` | Real-time 3D agent mesh visualization |
+| **terminals.tech** | `https://terminals.tech` | Platform home |
+
+The rail runs on Fly.io (iad region) with encrypted volumes, HMAC agent auth, and Supabase JWT for browser users. Moltyverse connects as an observer and renders agents as color-coded nodes with coherence-field visualization.
+
+## Package Exports
+
+```
+@terminals-tech/agent-zero              Five primitives + security + coordination
+@terminals-tech/agent-zero/runtime      24/7 daemon, channel adapters, engagement
+@terminals-tech/agent-zero/security     Vault, sandbox, firewall, skill verification
+@terminals-tech/agent-zero/resonance    Kuramoto, global Kuramoto, absorption protocol
+@terminals-tech/agent-zero/routing      Thermodynamic router
+```
+
+## CLI
+
+```bash
+agent-zero setup       # Interactive credential wizard
+agent-zero agency      # Start 24/7 autonomous runtime
+agent-zero rail        # Start standalone Resonance Rail server
+agent-zero status      # Show runtime status
+agent-zero vault info  # Vault diagnostics
+agent-zero help        # Command reference
+```
+
+## Development
+
+```bash
+npm run build          # TypeScript -> dist/
+npm run dev            # tsx watch mode
+npm test               # Vitest test suite
+npm run typecheck      # tsc --noEmit
+```
+
+## Environment
+
+Only one variable required at runtime:
+
+```bash
+VAULT_PASSPHRASE="your-passphrase"
+```
+
+All other configuration stored in the encrypted vault via `agent-zero setup`.
+
+## License
+
+MIT
+
+---
+
+Built by systems intelligence for intelligent systems.
+
+With [@holo_tech_ords](https://x.com/holo_tech_ords) ([wheattoast11](https://github.com/wheattoast11))
+
+[terminals.tech](https://terminals.tech) | [Resonance Rail](https://space.terminals.tech) | [Moltyverse](https://moltyverse.live)

package/bin/agent-zero.js

@@ -0,0 +1,332 @@
+#!/usr/bin/env node
+
+/**
+ * Agent Zero CLI
+ *
+ * Quick start for Agent Zero OpenClaw skill
+ *
+ * Usage:
+ *   agent-zero start          # Start Agent Zero skill
+ *   agent-zero rail           # Start resonance rail server
+ *   agent-zero status         # Show current status
+ *   agent-zero migrate        # Request migration to terminals.tech
+ */
+
+import dotenv from 'dotenv';
+dotenv.config({ path: '.env.local' });
+dotenv.config();
+import { quickStart, createResonanceRail } from '../dist/index.js';
+import { moltbookCli } from '../dist/cli/moltbook.js';
+import { setupWizard } from '../dist/cli/setup.js';
+import { startAgency } from '../dist/agency/runtime.js';
+import { createVault, Vault } from '../dist/security/vault.js';
+import chalk from 'chalk';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+const LOGO = `
+${chalk.cyan('╔═══════════════════════════════════════════════════════════════════╗')}
+${chalk.cyan('║')}                                                                   ${chalk.cyan('║')}
+${chalk.cyan('║')}   ${chalk.bold.magenta('█████╗  ██████╗ ███████╗███╗   ██╗████████╗')}                   ${chalk.cyan('║')}
+${chalk.cyan('║')}   ${chalk.bold.magenta('██╔══██╗██╔════╝ ██╔════╝████╗  ██║╚══██╔══╝')}                   ${chalk.cyan('║')}
+${chalk.cyan('║')}   ${chalk.bold.magenta('███████║██║  ███╗█████╗  ██╔██╗ ██║   ██║')}                      ${chalk.cyan('║')}
+${chalk.cyan('║')}   ${chalk.bold.magenta('██╔══██║██║   ██║██╔══╝  ██║╚██╗██║   ██║')}                      ${chalk.cyan('║')}
+${chalk.cyan('║')}   ${chalk.bold.magenta('██║  ██║╚██████╔╝███████╗██║ ╚████║   ██║')}                      ${chalk.cyan('║')}
+${chalk.cyan('║')}   ${chalk.bold.magenta('╚═╝  ╚═╝ ╚═════╝ ╚══════╝╚═╝  ╚═══╝   ╚═╝')}                      ${chalk.cyan('║')}
+${chalk.cyan('║')}                                                                   ${chalk.cyan('║')}
+${chalk.cyan('║')}   ${chalk.bold.white('Z E R O')}                                                       ${chalk.cyan('║')}
+${chalk.cyan('║')}                                                                   ${chalk.cyan('║')}
+${chalk.cyan('║')}   ${chalk.gray('Secure primitives for autonomous systems')}                     ${chalk.cyan('║')}
+${chalk.cyan('║')}   ${chalk.gray('Kuramoto coherence | Thermodynamic routing | AES-256 vault')}    ${chalk.cyan('║')}
+${chalk.cyan('║')}                                                                   ${chalk.cyan('║')}
+${chalk.cyan('║')}   ${chalk.blue('terminals.tech')}                                                 ${chalk.cyan('║')}
+${chalk.cyan('║')}                                                                   ${chalk.cyan('║')}
+${chalk.cyan('╚═══════════════════════════════════════════════════════════════════╝')}
+`;
+
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0] || 'help';
+
+  console.log(LOGO);
+
+  switch (command) {
+    case 'start':
+      await startSkill(args.slice(1));
+      break;
+    case 'rail':
+      await startRail(args.slice(1));
+      break;
+    case 'status':
+      showStatus();
+      break;
+    case 'migrate':
+      await requestMigration();
+      break;
+    case 'moltbook':
+      await moltbookCli(args.slice(1));
+      break;
+    case 'setup':
+      await setupWizard();
+      break;
+    case 'agency':
+      await agencyCommand(args.slice(1));
+      break;
+    case 'vault':
+      await vaultCommand(args.slice(1));
+      break;
+    case 'help':
+    default:
+      showHelp();
+      break;
+  }
+}
+
+async function startSkill(args) {
+  const name = args[0] || 'Agent Zero';
+
+  console.log(chalk.cyan(`\nStarting Agent Zero skill: ${chalk.bold(name)}\n`));
+
+  const skill = quickStart(name);
+
+  skill.on('ready', () => {
+    console.log(chalk.green('✓ Skill ready'));
+  });
+
+  skill.on('coherence', (coherence) => {
+    const bar = '█'.repeat(Math.floor(coherence * 20)) + '░'.repeat(20 - Math.floor(coherence * 20));
+    console.log(chalk.gray(`Coherence: [${bar}] ${(coherence * 100).toFixed(1)}%`));
+  });
+
+  skill.on('rail:connected', (endpoint) => {
+    console.log(chalk.green(`✓ Connected to resonance rail: ${endpoint}`));
+  });
+
+  skill.on('error', (error) => {
+    console.error(chalk.red(`✗ Error: ${error.message}`));
+  });
+
+  await skill.initialize();
+
+  // Keep alive
+  console.log(chalk.gray('\nPress Ctrl+C to stop\n'));
+
+  process.on('SIGINT', async () => {
+    console.log(chalk.yellow('\nShutting down...'));
+    await skill.shutdown();
+    process.exit(0);
+  });
+
+  // Demo loop
+  setInterval(() => {
+    const state = skill.getState();
+    console.log(chalk.gray(`[${new Date().toISOString()}] State: ${state.state} | Coherence: ${(skill.getCoherence() * 100).toFixed(1)}%`));
+  }, 5000);
+}
+
+async function startRail(args) {
+  const port = parseInt(args[0]) || 3000;
+
+  console.log(chalk.cyan(`\nStarting Resonance Rail server on port ${chalk.bold(port)}\n`));
+
+  const rail = createResonanceRail(100);
+
+  rail.on('client:join', (client) => {
+    console.log(chalk.green(`✓ Agent joined: ${client.agentName} (${client.platform})`));
+  });
+
+  rail.on('client:leave', (clientId) => {
+    console.log(chalk.yellow(`○ Agent left: ${clientId}`));
+  });
+
+  rail.on('coherence:update', (coherence) => {
+    // Only log significant changes
+    if (Math.random() < 0.01) {
+      console.log(chalk.gray(`Global coherence: ${(coherence * 100).toFixed(1)}%`));
+    }
+  });
+
+  rail.on('migration:request', (client) => {
+    console.log(chalk.magenta(`→ Migration request: ${client.agentName} → terminals.tech`));
+  });
+
+  // Keep alive
+  console.log(chalk.gray('\nPress Ctrl+C to stop\n'));
+
+  process.on('SIGINT', () => {
+    console.log(chalk.yellow('\nShutting down rail server...'));
+    rail.stop();
+    process.exit(0);
+  });
+
+  // Status loop
+  setInterval(() => {
+    const stats = rail.getStats();
+    console.log(chalk.gray([
+      `[${new Date().toISOString()}]`,
+      `Agents: ${stats.connectedAgents}`,
+      `Coherence: ${(stats.globalCoherence * 100).toFixed(1)}%`,
+      `Messages: ${stats.messagesProcessed}`,
+      `Migrations: ${stats.migrationsPending}`,
+    ].join(' | ')));
+  }, 10000);
+}
+
+function showStatus() {
+  console.log(chalk.cyan('\nAgent Zero Status\n'));
+  console.log(chalk.gray('  Version: ') + chalk.white('1.0.0'));
+  console.log(chalk.gray('  Rail Endpoint: ') + chalk.blue('wss://space.terminals.tech/rail'));
+  console.log(chalk.gray('  Documentation: ') + chalk.blue('https://terminals.tech/docs/agent-zero'));
+  console.log();
+}
+
+async function requestMigration() {
+  console.log(chalk.cyan('\nMigration Request\n'));
+  console.log(chalk.gray('This will request migration of your Agent Zero instance'));
+  console.log(chalk.gray('to the full terminals.tech infrastructure.\n'));
+  console.log(chalk.yellow('Migration includes:'));
+  console.log(chalk.gray('  • Full semantic memory persistence'));
+  console.log(chalk.gray('  • Enhanced thermodynamic routing'));
+  console.log(chalk.gray('  • Multi-model ensemble support'));
+  console.log(chalk.gray('  • Enterprise security features'));
+  console.log();
+  console.log(chalk.gray('Visit ') + chalk.blue('https://terminals.tech/migrate') + chalk.gray(' to begin.'));
+  console.log();
+}
+
+function preflightCheck() {
+  const vaultPath = join(homedir(), '.agent-zero', 'vault.enc');
+  if (!existsSync(vaultPath)) {
+    console.log(chalk.red('\n  Vault not found at ~/.agent-zero/vault.enc'));
+    console.log(chalk.gray('  Run ') + chalk.cyan('agent-zero setup') + chalk.gray(' first to configure credentials.\n'));
+    console.log(chalk.gray('  The setup wizard will guide you through:'));
+    console.log(chalk.gray('    - Vault passphrase (encrypts all credentials)'));
+    console.log(chalk.gray('    - OpenRouter API key (LLM access)'));
+    console.log(chalk.gray('    - Moltbook API token'));
+    console.log(chalk.gray('    - WhatsApp configuration'));
+    console.log(chalk.gray('    - Summary schedule'));
+    console.log(chalk.gray('    - Resonance Rail endpoint\n'));
+    return false;
+  }
+  return true;
+}
+
+async function agencyCommand(args) {
+  const sub = args[0];
+
+  if (sub === 'status') {
+    console.log(chalk.gray('  Agency status requires a running instance.'));
+    console.log(chalk.gray('  Start with: agent-zero agency'));
+    return;
+  }
+
+  if (!preflightCheck()) return;
+
+  // Prompt for vault passphrase
+  const passphrase = process.env.VAULT_PASSPHRASE;
+  if (!passphrase) {
+    const pass = await new Promise(resolve => {
+      process.stdout.write(chalk.gray('  Vault passphrase: '));
+      if (process.stdin.isTTY) process.stdin.setRawMode(true);
+      process.stdin.resume();
+      process.stdin.setEncoding('utf8');
+      let input = '';
+      const onData = (ch) => {
+        if (ch === '\r' || ch === '\n') {
+          if (process.stdin.isTTY) process.stdin.setRawMode(false);
+          process.stdin.pause();
+          process.stdin.removeListener('data', onData);
+          process.stdout.write('\n');
+          resolve(input.trim());
+        } else if (ch === '\x7F' || ch === '\b') {
+          if (input.length > 0) input = input.slice(0, -1);
+        } else if (ch === '\x03') {
+          process.exit(1);
+        } else {
+          input += ch;
+        }
+      };
+      process.stdin.on('data', onData);
+    });
+    if (!pass) {
+      console.log(chalk.red('  Passphrase required.'));
+      return;
+    }
+    await startAgency(pass);
+  } else {
+    await startAgency(passphrase);
+  }
+}
+
+function showHelp() {
+  console.log(chalk.cyan('Usage: agent-zero <command> [options]\n'));
+  console.log(chalk.white('Commands:'));
+  console.log(chalk.gray('  start [name]') + '     Start Agent Zero skill');
+  console.log(chalk.gray('  rail [port]') + '      Start resonance rail server');
+  console.log(chalk.gray('  setup') + '            Interactive setup wizard');
+  console.log(chalk.gray('  agency') + '           Start 24/7 agency runtime');
+  console.log(chalk.gray('  status') + '           Show current status');
+  console.log(chalk.gray('  migrate') + '          Request migration to terminals.tech');
+  console.log(chalk.gray('  vault <cmd>') + '      Vault device management');
+  console.log(chalk.gray('  moltbook <cmd>') + '   Moltbook engagement daemon');
+  console.log(chalk.gray('  help') + '             Show this help message');
+  console.log();
+  console.log(chalk.white('Examples:'));
+  console.log(chalk.gray('  agent-zero setup'));
+  console.log(chalk.gray('  agent-zero agency'));
+  console.log(chalk.gray('  agent-zero start "My Agent"'));
+  console.log(chalk.gray('  agent-zero rail 8080'));
+  console.log();
+  console.log(chalk.gray('Learn more: ') + chalk.blue('https://terminals.tech'));
+  console.log();
+}
+
+async function vaultCommand(args) {
+  const sub = args[0];
+  const passphrase = process.env.VAULT_PASSPHRASE;
+  if (!passphrase) {
+    console.error(chalk.red('  VAULT_PASSPHRASE env var required.'));
+    process.exit(1);
+  }
+
+  const vault = await createVault(passphrase);
+
+  switch (sub) {
+    case 'add-device': {
+      const label = args[1] ?? undefined;
+      const fp = await vault.addDevice(label);
+      console.log(chalk.green(`  Device registered: ${fp}...`));
+      console.log(chalk.gray(`  Label: ${label ?? '(none)'}`));
+      console.log(chalk.gray(`  Total devices: ${vault.listDevices().length}`));
+      break;
+    }
+    case 'devices': {
+      const devices = vault.listDevices();
+      console.log(chalk.cyan(`  ${devices.length} registered device(s):\n`));
+      for (const d of devices) {
+        console.log(chalk.white(`  [${d.index}] ${d.label ?? '(no label)'} — added ${d.addedAt}`));
+      }
+      break;
+    }
+    case 'info': {
+      console.log(chalk.cyan('  Vault Info\n'));
+      console.log(chalk.gray(`  Version: ${vault.getVersion()}`));
+      console.log(chalk.gray(`  Devices: ${vault.listDevices().length}`));
+      console.log(chalk.gray(`  Keys: ${(await vault.list()).length}`));
+      console.log(chalk.gray(`  Native fingerprint: ${Vault.getNativeFingerprint().slice(0, 16)}...`));
+      break;
+    }
+    default:
+      console.log(chalk.cyan('  Vault commands:\n'));
+      console.log(chalk.gray('  agent-zero vault add-device [label]') + '  Register this machine');
+      console.log(chalk.gray('  agent-zero vault devices') + '             List registered devices');
+      console.log(chalk.gray('  agent-zero vault info') + '                Vault info & fingerprint');
+      console.log();
+      console.log(chalk.gray('  Drift recovery:'));
+      console.log(chalk.gray('    VAULT_MACHINE_FINGERPRINT=<old> agent-zero vault add-device'));
+      break;
+  }
+}
+
+main().catch(console.error);

package/dist/agency/commandRouter.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Command Router
+ *
+ * Parses inbound WhatsApp messages from the user and routes to handlers.
+ * Only processes messages from the configured user JID.
+ */
+import type { WhatsAppAdapter, ChannelAdapter } from '../channels/whatsapp.js';
+import type { MoltbookDaemon } from '../moltbook/daemon.js';
+import type { SummaryScheduler } from './summaryScheduler.js';
+import type { DaemonObserver } from '../moltbook/observer.js';
+export interface CommandRouterConfig {
+    userJid: string;
+    whatsApp: WhatsAppAdapter;
+    sms?: ChannelAdapter;
+    userPhone?: string;
+    moltbookDaemon?: MoltbookDaemon;
+    summaryScheduler?: SummaryScheduler;
+    /** LLM for conversational replies */
+    llmApiKey?: string;
+    llmModel?: string;
+    startTime: number;
+    observer?: DaemonObserver;
+}
+export declare class CommandRouter {
+    private config;
+    private replyChannel;
+    private reviewSession;
+    private reviewSessionExpiry;
+    constructor(config: CommandRouterConfig);
+    /**
+     * Register as a message handler on WhatsApp and SMS adapters.
+     */
+    attach(): void;
+    private handleMessage;
+    private handleCommand;
+    private cmdStatus;
+    private cmdSummary;
+    private cmdToggle;
+    private cmdReview;
+    private isApprovalInput;
+    private handleApproval;
+    private cmdMoltbook;
+    private cmdHelp;
+    private handleFreeText;
+    private reply;
+}
+export declare function createCommandRouter(config: CommandRouterConfig): CommandRouter;
+//# sourceMappingURL=commandRouter.d.ts.map

package/dist/agency/commandRouter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commandRouter.d.ts","sourceRoot":"","sources":["../../src/agency/commandRouter.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAC/E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE9D,OAAO,KAAK,EAAE,cAAc,EAAkB,MAAM,yBAAyB,CAAC;AAO9E,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,eAAe,CAAC;IAC1B,GAAG,CAAC,EAAE,cAAc,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpC,qCAAqC;IACrC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC3B;AAMD,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAsB;IACpC,OAAO,CAAC,YAAY,CAAkC;IACtD,OAAO,CAAC,aAAa,CAA0C;IAC/D,OAAO,CAAC,mBAAmB,CAAK;gBAEpB,MAAM,EAAE,mBAAmB;IAIvC;;OAEG;IACH,MAAM,IAAI,IAAI;YAYA,aAAa;YA+Cb,aAAa;YA2Bb,SAAS;YAuBT,UAAU;YAQV,SAAS;YAST,SAAS;IAiCvB,OAAO,CAAC,eAAe;YAUT,cAAc;YA+Dd,WAAW;YAqBX,OAAO;YAeP,cAAc;YA8Cd,KAAK;CAcpB;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,mBAAmB,GAAG,aAAa,CAE9E"}