intent-hub 0.1.0

package/packages/agent/dist/plugin/index.d.ts

@@ -0,0 +1,3 @@
+export { IntentHubPlugin, intentHub } from './intent-hub-plugin.js';
+export type { IntentHubPluginConfig, LockInfo, BlockedInfo } from './intent-hub-plugin.js';
+//# sourceMappingURL=index.d.ts.map

package/packages/agent/dist/plugin/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/plugin/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,wBAAwB,CAAC;AACpE,YAAY,EAAE,qBAAqB,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC"}

package/packages/agent/dist/plugin/intent-hub-plugin.d.ts

@@ -0,0 +1,54 @@
+import type { HubMessage, BroadcastMessage } from '@anthropic-for-korea/intent-hub-shared';
+export interface IntentHubPluginConfig {
+    hubUrl: string;
+    userId: string;
+    username: string;
+    projectPath: string;
+}
+export interface LockInfo {
+    domain: string;
+    username: string;
+    intentSummary: string;
+}
+export interface BlockedInfo {
+    intentId: string;
+    blockedBy: Array<{
+        domain: string;
+        username: string;
+        intentSummary: string;
+    }>;
+}
+type MessageCallback = (message: HubMessage | BroadcastMessage) => void;
+type ConnectedCallback = (sessionId: string) => void;
+type DisconnectedCallback = () => void;
+type LockAcquiredCallback = (intentId: string, domains: string[]) => void;
+type LockBlockedCallback = (info: BlockedInfo) => void;
+type LockUpdateCallback = (locks: LockInfo[]) => void;
+export declare class IntentHubPlugin {
+    private client;
+    private config;
+    private currentLocks;
+    private messageCallbacks;
+    private connectedCallbacks;
+    private disconnectedCallbacks;
+    private lockAcquiredCallbacks;
+    private lockBlockedCallbacks;
+    private lockUpdateCallbacks;
+    initialize(config: IntentHubPluginConfig): void;
+    connect(): void;
+    disconnect(): void;
+    submitIntent(prompt: string): void;
+    isConnected(): boolean;
+    getSessionId(): string | null;
+    getCurrentLocks(): LockInfo[];
+    onMessage(callback: MessageCallback): () => void;
+    onConnected(callback: ConnectedCallback): () => void;
+    onDisconnected(callback: DisconnectedCallback): () => void;
+    onLockAcquired(callback: LockAcquiredCallback): () => void;
+    onLockBlocked(callback: LockBlockedCallback): () => void;
+    onLockUpdate(callback: LockUpdateCallback): () => void;
+    private handleMessage;
+}
+export declare const intentHub: IntentHubPlugin;
+export {};
+//# sourceMappingURL=intent-hub-plugin.d.ts.map

package/packages/agent/dist/plugin/intent-hub-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intent-hub-plugin.d.ts","sourceRoot":"","sources":["../../src/plugin/intent-hub-plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,wCAAwC,CAAC;AAG3F,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,QAAQ;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,KAAK,CAAC;QACf,MAAM,EAAE,MAAM,CAAC;QACf,QAAQ,EAAE,MAAM,CAAC;QACjB,aAAa,EAAE,MAAM,CAAC;KACvB,CAAC,CAAC;CACJ;AAED,KAAK,eAAe,GAAG,CAAC,OAAO,EAAE,UAAU,GAAG,gBAAgB,KAAK,IAAI,CAAC;AACxE,KAAK,iBAAiB,GAAG,CAAC,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;AACrD,KAAK,oBAAoB,GAAG,MAAM,IAAI,CAAC;AACvC,KAAK,oBAAoB,GAAG,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,IAAI,CAAC;AAC1E,KAAK,mBAAmB,GAAG,CAAC,IAAI,EAAE,WAAW,KAAK,IAAI,CAAC;AACvD,KAAK,kBAAkB,GAAG,CAAC,KAAK,EAAE,QAAQ,EAAE,KAAK,IAAI,CAAC;AAEtD,qBAAa,eAAe;IAC1B,OAAO,CAAC,MAAM,CAA0B;IACxC,OAAO,CAAC,MAAM,CAAsC;IACpD,OAAO,CAAC,YAAY,CAAkB;IAEtC,OAAO,CAAC,gBAAgB,CAAmC;IAC3D,OAAO,CAAC,kBAAkB,CAAqC;IAC/D,OAAO,CAAC,qBAAqB,CAAwC;IACrE,OAAO,CAAC,qBAAqB,CAAwC;IACrE,OAAO,CAAC,oBAAoB,CAAuC;IACnE,OAAO,CAAC,mBAAmB,CAAsC;IAEjE,UAAU,CAAC,MAAM,EAAE,qBAAqB,GAAG,IAAI;IAuB/C,OAAO,IAAI,IAAI;IAOf,UAAU,IAAI,IAAI;IAIlB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAOlC,WAAW,IAAI,OAAO;IAItB,YAAY,IAAI,MAAM,GAAG,IAAI;IAI7B,eAAe,IAAI,QAAQ,EAAE;IAI7B,SAAS,CAAC,QAAQ,EAAE,eAAe,GAAG,MAAM,IAAI;IAKhD,WAAW,CAAC,QAAQ,EAAE,iBAAiB,GAAG,MAAM,IAAI;IAKpD,cAAc,CAAC,QAAQ,EAAE,oBAAoB,GAAG,MAAM,IAAI;IAK1D,cAAc,CAAC,QAAQ,EAAE,oBAAoB,GAAG,MAAM,IAAI;IAK1D,aAAa,CAAC,QAAQ,EAAE,mBAAmB,GAAG,MAAM,IAAI;IAKxD,YAAY,CAAC,QAAQ,EAAE,kBAAkB,GAAG,MAAM,IAAI;IAKtD,OAAO,CAAC,aAAa;CAuBtB;AAED,eAAO,MAAM,SAAS,iBAAwB,CAAC"}

package/packages/agent/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@anthropic-for-korea/intent-hub-agent",
+  "version": "0.1.0",
+  "description": "Client library for Intent Hub - connect AI agents to the coordination hub",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "bun build ./src/index.ts --outdir ./dist --target node && tsc --emitDeclarationOnly",
+    "dev": "bun build ./src/index.ts --outdir ./dist --target node --watch",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@anthropic-for-korea/intent-hub-shared": "^0.1.0",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/ws": "^8.5.13",
+    "typescript": "^5.7.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/anthropic-for-korea/intent-hub.git",
+    "directory": "packages/agent"
+  },
+  "license": "MIT",
+  "keywords": ["intent-hub", "llm", "ai", "agent", "coordination", "claude", "opencode"]
+}

package/packages/agent/src/connection/hub-client.ts

@@ -0,0 +1,152 @@
+import WebSocket from 'ws';
+import type {
+  AgentConnectMessage,
+  AgentIntentSubmitMessage,
+  AgentHeartbeatMessage,
+  HubMessage,
+  BroadcastMessage,
+} from '@anthropic-for-korea/intent-hub-shared';
+import { createMessage, parseMessage, serializeMessage } from '@anthropic-for-korea/intent-hub-shared';
+
+export interface HubClientOptions {
+  hubUrl: string;
+  userId: string;
+  username: string;
+  projectPath: string;
+  onConnected?: (sessionId: string) => void;
+  onDisconnected?: () => void;
+  onMessage?: (message: HubMessage | BroadcastMessage) => void;
+  onError?: (error: Error) => void;
+  reconnectInterval?: number;
+}
+
+export class HubClient {
+  private ws: WebSocket | null = null;
+  private sessionId: string | null = null;
+  private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
+  private heartbeatTimer: ReturnType<typeof setInterval> | null = null;
+  private isConnecting = false;
+  private shouldReconnect = true;
+
+  constructor(private options: HubClientOptions) {}
+
+  connect(): void {
+    if (this.ws || this.isConnecting) return;
+    
+    this.isConnecting = true;
+    this.shouldReconnect = true;
+
+    try {
+      this.ws = new WebSocket(this.options.hubUrl);
+      
+      this.ws.on('open', () => {
+        this.isConnecting = false;
+        this.sendConnect();
+        this.startHeartbeat();
+      });
+
+      this.ws.on('message', (data) => {
+        const message = parseMessage(data.toString());
+        if (message) {
+          this.handleMessage(message as HubMessage | BroadcastMessage);
+        }
+      });
+
+      this.ws.on('close', () => {
+        this.cleanup();
+        this.options.onDisconnected?.();
+        this.scheduleReconnect();
+      });
+
+      this.ws.on('error', (error) => {
+        this.options.onError?.(error);
+      });
+    } catch (error) {
+      this.isConnecting = false;
+      this.options.onError?.(error as Error);
+      this.scheduleReconnect();
+    }
+  }
+
+  disconnect(): void {
+    this.shouldReconnect = false;
+    this.cleanup();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+
+  submitIntent(prompt: string): void {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error('Not connected to hub');
+    }
+
+    const message = createMessage<AgentIntentSubmitMessage>('agent:intent:submit', {
+      payload: { prompt },
+    });
+    this.ws.send(serializeMessage(message));
+  }
+
+  isConnected(): boolean {
+    return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
+  }
+
+  getSessionId(): string | null {
+    return this.sessionId;
+  }
+
+  private sendConnect(): void {
+    if (!this.ws) return;
+
+    const message = createMessage<AgentConnectMessage>('agent:connect', {
+      payload: {
+        userId: this.options.userId,
+        username: this.options.username,
+        projectPath: this.options.projectPath,
+      },
+    });
+    this.ws.send(serializeMessage(message));
+  }
+
+  private handleMessage(message: HubMessage | BroadcastMessage): void {
+    if (message.type === 'hub:connected') {
+      this.sessionId = (message as any).payload.sessionId;
+      this.options.onConnected?.(this.sessionId!);
+    }
+
+    this.options.onMessage?.(message);
+  }
+
+  private startHeartbeat(): void {
+    this.heartbeatTimer = setInterval(() => {
+      if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+        const message = createMessage<AgentHeartbeatMessage>('agent:heartbeat', {});
+        this.ws.send(serializeMessage(message));
+      }
+    }, 30000);
+  }
+
+  private cleanup(): void {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.sessionId = null;
+    this.isConnecting = false;
+  }
+
+  private scheduleReconnect(): void {
+    if (!this.shouldReconnect) return;
+
+    const interval = this.options.reconnectInterval ?? 5000;
+    this.reconnectTimer = setTimeout(() => {
+      this.ws = null;
+      this.connect();
+    }, interval);
+  }
+}

package/packages/agent/src/connection/index.ts

@@ -0,0 +1 @@
+export { HubClient } from './hub-client.js';

package/packages/agent/src/hooks/index.ts

@@ -0,0 +1,2 @@
+export { IntentHubHooks, createIntentHubHooks } from './intent-hub-hooks.js';
+export type { HookContext, HookResult, IntentHubHooksConfig } from './intent-hub-hooks.js';

package/packages/agent/src/hooks/intent-hub-hooks.ts

@@ -0,0 +1,245 @@
+import type { HubMessage, BroadcastMessage } from '@anthropic-for-korea/intent-hub-shared';
+import { HubClient } from '../connection/hub-client.js';
+
+export interface HookContext {
+  toolName: string;
+  toolInput: Record<string, unknown>;
+  sessionId: string;
+  userId: string;
+  username: string;
+}
+
+export interface HookResult {
+  allow: boolean;
+  message?: string;
+  modifiedInput?: Record<string, unknown>;
+}
+
+export interface IntentHubHooksConfig {
+  hubUrl: string;
+  userId: string;
+  username: string;
+  projectPath: string;
+  autoConnect?: boolean;
+  onNotification?: (event: string, data: unknown) => void;
+}
+
+export class IntentHubHooks {
+  private client: HubClient | null = null;
+  private config: IntentHubHooksConfig;
+  private currentIntent: string | null = null;
+  private blockedDomains: Set<string> = new Set();
+  private pendingDecisions: Map<string, {
+    resolve: (value: string) => void;
+    options: Array<{ id: string; description: string }>;
+  }> = new Map();
+
+  constructor(config: IntentHubHooksConfig) {
+    this.config = config;
+    if (config.autoConnect !== false) {
+      this.connect();
+    }
+  }
+
+  connect(): void {
+    this.client = new HubClient({
+      hubUrl: this.config.hubUrl,
+      userId: this.config.userId,
+      username: this.config.username,
+      projectPath: this.config.projectPath,
+      onConnected: (sessionId) => {
+        console.log(`[IntentHub] Connected to hub (session: ${sessionId})`);
+      },
+      onDisconnected: () => {
+        console.log('[IntentHub] Disconnected from hub');
+      },
+      onMessage: (message) => this.handleMessage(message),
+      onError: (error) => {
+        console.error('[IntentHub] Connection error:', error.message);
+      },
+    });
+    this.client.connect();
+  }
+
+  disconnect(): void {
+    this.client?.disconnect();
+    this.client = null;
+  }
+
+  async preToolUse(context: HookContext): Promise<HookResult> {
+    const editTools = ['edit', 'write', 'Edit', 'Write', 'MultiEdit'];
+    
+    if (!editTools.includes(context.toolName)) {
+      return { allow: true };
+    }
+
+    const filePath = context.toolInput['filePath'] as string | undefined;
+    if (!filePath) {
+      return { allow: true };
+    }
+
+    const domain = this.inferDomainFromPath(filePath);
+    
+    if (this.blockedDomains.has(domain)) {
+      return {
+        allow: false,
+        message: `⚠️ [IntentHub] This domain (${domain}) is currently being worked on by another team member. Please wait or work on a different area.`,
+      };
+    }
+
+    if (!this.currentIntent && this.client?.isConnected()) {
+      const prompt = `Editing file: ${filePath}`;
+      this.client.submitIntent(prompt);
+    }
+
+    return { allow: true };
+  }
+
+  async postToolUse(context: HookContext, result: unknown): Promise<void> {
+    const editTools = ['edit', 'write', 'Edit', 'Write', 'MultiEdit'];
+    
+    if (!editTools.includes(context.toolName)) {
+      return;
+    }
+  }
+
+  async onUserPromptSubmit(prompt: string): Promise<{ 
+    modifiedPrompt?: string; 
+    cancel?: boolean;
+    message?: string;
+  }> {
+    if (!this.client?.isConnected()) {
+      return {};
+    }
+
+    this.client.submitIntent(prompt);
+
+    await this.waitForResponse(1000);
+
+    if (this.blockedDomains.size > 0) {
+      const domains = Array.from(this.blockedDomains).join(', ');
+      return {
+        message: `⚠️ [IntentHub] Note: The following domains are currently locked by other team members: ${domains}. Your work may be queued.`,
+      };
+    }
+
+    return {};
+  }
+
+  async onStop(): Promise<void> {
+    if (this.currentIntent) {
+      this.currentIntent = null;
+    }
+    this.blockedDomains.clear();
+  }
+
+  submitDecision(conflictId: string, choice: string): void {
+    const pending = this.pendingDecisions.get(conflictId);
+    if (pending) {
+      pending.resolve(choice);
+      this.pendingDecisions.delete(conflictId);
+    }
+  }
+
+  private handleMessage(message: HubMessage | BroadcastMessage): void {
+    switch (message.type) {
+      case 'hub:lock:acquired': {
+        const payload = (message as any).payload;
+        this.currentIntent = payload.intentId;
+        this.config.onNotification?.('lock:acquired', {
+          domains: payload.domains,
+        });
+        break;
+      }
+      
+      case 'hub:lock:blocked': {
+        const payload = (message as any).payload;
+        for (const block of payload.blockedBy) {
+          this.blockedDomains.add(block.domain);
+        }
+        this.config.onNotification?.('lock:blocked', {
+          blockedBy: payload.blockedBy,
+        });
+        break;
+      }
+
+      case 'hub:negotiation:start': {
+        const payload = (message as any).payload;
+        this.config.onNotification?.('negotiation:start', payload);
+        break;
+      }
+
+      case 'hub:negotiation:resolved': {
+        const payload = (message as any).payload;
+        this.blockedDomains.clear();
+        this.config.onNotification?.('negotiation:resolved', payload);
+        break;
+      }
+
+      case 'hub:decision:required': {
+        const payload = (message as any).payload;
+        this.config.onNotification?.('decision:required', payload);
+        break;
+      }
+
+      case 'broadcast:lock:update': {
+        const payload = (message as any).payload;
+        this.blockedDomains.clear();
+        for (const lock of payload.locks) {
+          if (lock.username !== this.config.username) {
+            this.blockedDomains.add(lock.domainId);
+          }
+        }
+        this.config.onNotification?.('locks:updated', { locks: payload.locks });
+        break;
+      }
+
+      case 'broadcast:user:joined': {
+        const payload = (message as any).payload;
+        this.config.onNotification?.('user:joined', payload);
+        break;
+      }
+
+      case 'broadcast:user:left': {
+        const payload = (message as any).payload;
+        this.config.onNotification?.('user:left', payload);
+        break;
+      }
+    }
+  }
+
+  private inferDomainFromPath(filePath: string): string {
+    const lower = filePath.toLowerCase();
+    
+    if (lower.includes('/auth/') || lower.includes('auth.')) return 'auth';
+    if (lower.includes('/user/') || lower.includes('user.')) return 'user';
+    if (lower.includes('/payment/') || lower.includes('payment.')) return 'payment';
+    if (lower.includes('/api/') || lower.includes('route')) return 'api';
+    if (lower.includes('/component') || lower.includes('.tsx') || lower.includes('.jsx')) return 'ui';
+    if (lower.includes('/test/') || lower.includes('.test.') || lower.includes('.spec.')) return 'test';
+    if (lower.includes('config') || lower.includes('.env')) return 'config';
+    if (lower.includes('/db/') || lower.includes('database') || lower.includes('migration')) return 'database';
+    
+    return 'general';
+  }
+
+  private waitForResponse(ms: number): Promise<void> {
+    return new Promise(resolve => setTimeout(resolve, ms));
+  }
+
+  isConnected(): boolean {
+    return this.client?.isConnected() ?? false;
+  }
+
+  getBlockedDomains(): string[] {
+    return Array.from(this.blockedDomains);
+  }
+
+  getCurrentIntent(): string | null {
+    return this.currentIntent;
+  }
+}
+
+export function createIntentHubHooks(config: IntentHubHooksConfig): IntentHubHooks {
+  return new IntentHubHooks(config);
+}

package/packages/agent/src/index.ts

@@ -0,0 +1,5 @@
+export { HubClient } from './connection/index.js';
+export { IntentHubPlugin, intentHub } from './plugin/index.js';
+export type { IntentHubPluginConfig, LockInfo, BlockedInfo } from './plugin/index.js';
+export { IntentHubHooks, createIntentHubHooks } from './hooks/index.js';
+export type { HookContext, HookResult, IntentHubHooksConfig } from './hooks/index.js';

package/packages/agent/src/plugin/index.ts

@@ -0,0 +1,2 @@
+export { IntentHubPlugin, intentHub } from './intent-hub-plugin.js';
+export type { IntentHubPluginConfig, LockInfo, BlockedInfo } from './intent-hub-plugin.js';

package/packages/agent/src/plugin/intent-hub-plugin.ts

@@ -0,0 +1,153 @@
+import type { HubMessage, BroadcastMessage } from '@anthropic-for-korea/intent-hub-shared';
+import { HubClient } from '../connection/hub-client.js';
+
+export interface IntentHubPluginConfig {
+  hubUrl: string;
+  userId: string;
+  username: string;
+  projectPath: string;
+}
+
+export interface LockInfo {
+  domain: string;
+  username: string;
+  intentSummary: string;
+}
+
+export interface BlockedInfo {
+  intentId: string;
+  blockedBy: Array<{
+    domain: string;
+    username: string;
+    intentSummary: string;
+  }>;
+}
+
+type MessageCallback = (message: HubMessage | BroadcastMessage) => void;
+type ConnectedCallback = (sessionId: string) => void;
+type DisconnectedCallback = () => void;
+type LockAcquiredCallback = (intentId: string, domains: string[]) => void;
+type LockBlockedCallback = (info: BlockedInfo) => void;
+type LockUpdateCallback = (locks: LockInfo[]) => void;
+
+export class IntentHubPlugin {
+  private client: HubClient | null = null;
+  private config: IntentHubPluginConfig | null = null;
+  private currentLocks: LockInfo[] = [];
+
+  private messageCallbacks: Set<MessageCallback> = new Set();
+  private connectedCallbacks: Set<ConnectedCallback> = new Set();
+  private disconnectedCallbacks: Set<DisconnectedCallback> = new Set();
+  private lockAcquiredCallbacks: Set<LockAcquiredCallback> = new Set();
+  private lockBlockedCallbacks: Set<LockBlockedCallback> = new Set();
+  private lockUpdateCallbacks: Set<LockUpdateCallback> = new Set();
+
+  initialize(config: IntentHubPluginConfig): void {
+    this.config = config;
+    this.client = new HubClient({
+      hubUrl: config.hubUrl,
+      userId: config.userId,
+      username: config.username,
+      projectPath: config.projectPath,
+      onConnected: (sessionId) => {
+        this.connectedCallbacks.forEach(cb => cb(sessionId));
+      },
+      onDisconnected: () => {
+        this.disconnectedCallbacks.forEach(cb => cb());
+      },
+      onMessage: (message) => {
+        this.handleMessage(message);
+        this.messageCallbacks.forEach(cb => cb(message));
+      },
+      onError: (error) => {
+        console.error('[IntentHub] Connection error:', error.message);
+      },
+    });
+  }
+
+  connect(): void {
+    if (!this.client) {
+      throw new Error('Plugin not initialized. Call initialize() first.');
+    }
+    this.client.connect();
+  }
+
+  disconnect(): void {
+    this.client?.disconnect();
+  }
+
+  submitIntent(prompt: string): void {
+    if (!this.client) {
+      throw new Error('Plugin not initialized');
+    }
+    this.client.submitIntent(prompt);
+  }
+
+  isConnected(): boolean {
+    return this.client?.isConnected() ?? false;
+  }
+
+  getSessionId(): string | null {
+    return this.client?.getSessionId() ?? null;
+  }
+
+  getCurrentLocks(): LockInfo[] {
+    return [...this.currentLocks];
+  }
+
+  onMessage(callback: MessageCallback): () => void {
+    this.messageCallbacks.add(callback);
+    return () => this.messageCallbacks.delete(callback);
+  }
+
+  onConnected(callback: ConnectedCallback): () => void {
+    this.connectedCallbacks.add(callback);
+    return () => this.connectedCallbacks.delete(callback);
+  }
+
+  onDisconnected(callback: DisconnectedCallback): () => void {
+    this.disconnectedCallbacks.add(callback);
+    return () => this.disconnectedCallbacks.delete(callback);
+  }
+
+  onLockAcquired(callback: LockAcquiredCallback): () => void {
+    this.lockAcquiredCallbacks.add(callback);
+    return () => this.lockAcquiredCallbacks.delete(callback);
+  }
+
+  onLockBlocked(callback: LockBlockedCallback): () => void {
+    this.lockBlockedCallbacks.add(callback);
+    return () => this.lockBlockedCallbacks.delete(callback);
+  }
+
+  onLockUpdate(callback: LockUpdateCallback): () => void {
+    this.lockUpdateCallbacks.add(callback);
+    return () => this.lockUpdateCallbacks.delete(callback);
+  }
+
+  private handleMessage(message: HubMessage | BroadcastMessage): void {
+    switch (message.type) {
+      case 'hub:lock:acquired': {
+        const payload = (message as any).payload;
+        this.lockAcquiredCallbacks.forEach(cb => cb(payload.intentId, payload.domains));
+        break;
+      }
+      case 'hub:lock:blocked': {
+        const payload = (message as any).payload;
+        this.lockBlockedCallbacks.forEach(cb => cb({
+          intentId: payload.intentId,
+          blockedBy: payload.blockedBy,
+        }));
+        break;
+      }
+      case 'broadcast:lock:update': {
+        const payload = (message as any).payload;
+        this.currentLocks = payload.locks;
+        this.lockUpdateCallbacks.forEach(cb => cb(this.currentLocks));
+        break;
+      }
+    }
+  }
+}
+
+export const intentHub = new IntentHubPlugin();

package/packages/agent/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/packages/hub/.turbo/turbo-build.log

@@ -0,0 +1,6 @@
+$ bun build ./src/index.ts ./src/cli.ts --outdir ./dist --target node && tsc --emitDeclarationOnly
+Bundled 74 modules in 5ms
+
+  index.js  151.96 KB  (entry point)
+  cli.js    253.21 KB  (entry point)
+

package/packages/hub/.turbo/turbo-typecheck.log

@@ -0,0 +1 @@
+$ tsc --noEmit