@omnixal/openclaw-nats-plugin 0.2.10 → 0.2.12

package/PLUGIN.md

@@ -53,6 +53,7 @@ Plugin hooks make lightweight HTTP calls to a NATS sidecar service for event pub
 | Subject | Trigger |
 |---|---|
 | `agent.events.gateway.startup` | Gateway starts |
+| `agent.events.gateway.stopped` | Gateway stops |
 | `agent.events.session.new` | `/new` command |
 | `agent.events.session.reset` | `/reset` command |
 | `agent.events.session.stop` | `/stop` command |
@@ -60,10 +61,13 @@ Plugin hooks make lightweight HTTP calls to a NATS sidecar service for event pub
 | `agent.events.session.ended` | Session ends |
 | `agent.events.tool.{name}.completed` | Tool succeeds |
 | `agent.events.tool.{name}.failed` | Tool fails |
+| `agent.events.message.received` | Inbound message received |
+| `agent.events.message.sent` | Message delivered |
+| `agent.events.llm.output` | LLM response received |
+| `agent.events.subagent.spawning` | Subagent about to spawn |
 | `agent.events.subagent.spawned` | Subagent created |
 | `agent.events.subagent.ended` | Subagent finished |
 | `agent.events.agent.run_ended` | Agent run completes |
-| `agent.events.message.sent` | Message delivered |
 | `agent.events.context.compacted` | Context history compressed |
 
 ## Dashboard
@@ -90,6 +94,8 @@ Environment variables (auto-configured by setup):
 - `NATS_SIDECAR_URL` — Sidecar URL (default: `http://127.0.0.1:3104`)
 - `NATS_PLUGIN_API_KEY` — API key for sidecar auth (auto-generated)
 - `NATS_SERVERS` — NATS server URL (default: `nats://127.0.0.1:4222`)
+- `OPENCLAW_GATEWAY_URL` — Gateway HTTP URL (default: `http://127.0.0.1:18789`)
+- `OPENCLAW_HOOK_TOKEN` — Webhook token for event delivery to agent session (from `hooks.token` in gateway config)
 
 ## Requirements
 

package/cli/bun-setup.ts

@@ -54,18 +54,18 @@ export async function bunSetup(): Promise<void> {
     NATS_SIDECAR_URL: 'http://127.0.0.1:3104',
     NATS_PLUGIN_API_KEY: apiKey,
     NATS_SERVERS: 'nats://127.0.0.1:4222',
-    OPENCLAW_WS_URL: 'ws://127.0.0.1:18789',
+    OPENCLAW_GATEWAY_URL: 'http://127.0.0.1:18789',
   };
   writeEnvVariables(envVars);
 
   // Write .env into sidecar dir so loadDotEnv picks it up
-  // Explicit localhost values override any container-level env (e.g. OPENCLAW_WS_URL=ws://openclaw:...)
+  // Explicit localhost values override any container-level env
   const sidecarEnv = [
     `PORT=3104`,
     `DB_PATH=${join(DATA_DIR, 'nats-sidecar.db')}`,
     `NATS_SERVERS=nats://127.0.0.1:4222`,
     `NATS_PLUGIN_API_KEY=${apiKey}`,
-    `OPENCLAW_WS_URL=ws://127.0.0.1:18789`,
+    `OPENCLAW_GATEWAY_URL=http://127.0.0.1:18789`,
   ].join('\n');
   writeFileSync(join(SIDECAR_DIR, '.env'), sidecarEnv, 'utf-8');
 

package/dashboard/src/lib/EventsReferenceModal.svelte

@@ -0,0 +1,59 @@
+<script lang="ts">
+  import { Modal } from '$lib/components/ui/modal';
+  import * as Table from '$lib/components/ui/table';
+
+  interface Props {
+    open: boolean;
+    onClose: () => void;
+  }
+
+  let { open, onClose }: Props = $props();
+
+  const events = [
+    { subject: 'agent.events.gateway.startup', trigger: 'Gateway started', payload: '{}' },
+    { subject: 'agent.events.gateway.stopped', trigger: 'Gateway stopped', payload: '{ reason }' },
+    { subject: 'agent.events.session.new', trigger: '/new command', payload: '{ sessionKey, command }' },
+    { subject: 'agent.events.session.reset', trigger: '/reset command', payload: '{ sessionKey, command }' },
+    { subject: 'agent.events.session.stop', trigger: '/stop command', payload: '{ sessionKey, command }' },
+    { subject: 'agent.events.session.started', trigger: 'Session began', payload: '{ sessionKey, sessionId, channel }' },
+    { subject: 'agent.events.session.ended', trigger: 'Session ended', payload: '{ sessionKey, sessionId, channel }' },
+    { subject: 'agent.events.agent.run_ended', trigger: 'Agent run completed', payload: '{ sessionKey, runId, messageCount }' },
+    { subject: 'agent.events.tool.{name}.completed', trigger: 'Tool succeeded', payload: '{ sessionKey, toolName, durationMs }' },
+    { subject: 'agent.events.tool.{name}.failed', trigger: 'Tool failed', payload: '{ sessionKey, toolName, durationMs }' },
+    { subject: 'agent.events.message.received', trigger: 'Inbound message', payload: '{ from, content, metadata }' },
+    { subject: 'agent.events.message.sent', trigger: 'Message delivered', payload: '{ sessionKey, to, success, error }' },
+    { subject: 'agent.events.llm.output', trigger: 'LLM response', payload: '{ provider, model, usage }' },
+    { subject: 'agent.events.subagent.spawning', trigger: 'Subagent creating', payload: '{ childSessionKey, agentId, label, mode }' },
+    { subject: 'agent.events.subagent.spawned', trigger: 'Subagent created', payload: '{ sessionKey, subagentId, task }' },
+    { subject: 'agent.events.subagent.ended', trigger: 'Subagent finished', payload: '{ sessionKey, subagentId, result, durationMs }' },
+    { subject: 'agent.events.context.compacted', trigger: 'Context compressed', payload: '{ sessionKey }' },
+    { subject: 'agent.events.cron.*', trigger: 'Cron trigger', payload: '(user-defined)' },
+    { subject: 'agent.events.custom.*', trigger: 'Custom event', payload: '(user-defined)' },
+  ];
+</script>
+
+<Modal {open} title="Events Reference" {onClose} class="max-w-3xl">
+  <div class="max-h-[60vh] overflow-y-auto -mx-6 px-6">
+    <p class="text-xs text-muted-foreground mb-3">
+      All events published by the NATS plugin. Each event also includes a <code class="text-xs">timestamp</code> field.
+    </p>
+    <Table.Root>
+      <Table.Header>
+        <Table.Row>
+          <Table.Head>Subject</Table.Head>
+          <Table.Head>Trigger</Table.Head>
+          <Table.Head>Payload</Table.Head>
+        </Table.Row>
+      </Table.Header>
+      <Table.Body>
+        {#each events as ev}
+          <Table.Row>
+            <Table.Cell class="font-mono text-xs whitespace-nowrap">{ev.subject}</Table.Cell>
+            <Table.Cell class="text-xs">{ev.trigger}</Table.Cell>
+            <Table.Cell class="font-mono text-xs text-muted-foreground">{ev.payload}</Table.Cell>
+          </Table.Row>
+        {/each}
+      </Table.Body>
+    </Table.Root>
+  </div>
+</Modal>

package/dashboard/src/lib/MetricsPanel.svelte

@@ -1,15 +1,19 @@
 <script lang="ts">
   import * as Table from '$lib/components/ui/table';
   import { Badge } from '$lib/components/ui/badge';
+  import { Button } from '$lib/components/ui/button';
   import * as Card from '$lib/components/ui/card';
   import type { SubjectMetric } from '$lib/api';
   import { relativeAge } from '$lib/utils';
+  import CircleHelp from '@lucide/svelte/icons/circle-help';
+  import EventsReferenceModal from './EventsReferenceModal.svelte';
 
   interface Props {
     metrics: SubjectMetric[];
   }
 
   let { metrics }: Props = $props();
+  let showEventsRef = $state(false);
 
   let totalPublished = $derived(metrics.reduce((acc, m) => acc + m.published, 0));
   let totalConsumed = $derived(metrics.reduce((acc, m) => acc + m.consumed, 0));
@@ -17,7 +21,12 @@
 
 <Card.Root>
   <Card.Header class="pb-2">
-    <Card.Title class="text-sm font-medium">Queue Metrics</Card.Title>
+    <div class="flex items-center justify-between">
+      <Card.Title class="text-sm font-medium">Queue Metrics</Card.Title>
+      <Button variant="ghost" size="icon-sm" onclick={() => showEventsRef = true} title="Events reference">
+        <CircleHelp size={14} />
+      </Button>
+    </div>
   </Card.Header>
   <Card.Content>
     <div class="flex items-center gap-2 mb-3">
@@ -58,3 +67,5 @@
     {/if}
   </Card.Content>
 </Card.Root>
+
+<EventsReferenceModal open={showEventsRef} onClose={() => showEventsRef = false} />

package/dashboard/src/lib/components/ui/modal/modal.svelte

@@ -8,6 +8,7 @@
     onClose: () => void;
     children: Snippet;
     actions?: Snippet;
+    class?: string;
   }
 
   let {
@@ -16,6 +17,7 @@
     onClose,
     children,
     actions,
+    class: className,
   }: Props = $props();
 
   function handleKeydown(e: KeyboardEvent) {
@@ -31,7 +33,7 @@
   >
     <!-- svelte-ignore a11y_click_events_have_key_events a11y_no_static_element_interactions -->
     <div class="fixed inset-0" onclick={onClose}></div>
-    <div class="relative z-10 w-full max-w-lg rounded-lg border bg-background p-6 shadow-lg">
+    <div class="relative z-10 w-full {className ?? 'max-w-lg'} rounded-lg border bg-background p-6 shadow-lg">
       <div class="flex items-center justify-between mb-4">
         <h3 class="text-lg font-semibold">{title}</h3>
         <Button variant="ghost" size="icon-sm" onclick={onClose}>

package/docker/docker-compose.yml

@@ -29,7 +29,7 @@ services:
       - PORT=3104
       - DB_PATH=/app/data/nats-sidecar.db
       - NATS_SERVERS=nats://nats:4222
-      - OPENCLAW_WS_URL=ws://host.docker.internal:18789
+      - OPENCLAW_GATEWAY_URL=http://host.docker.internal:18789
       - NATS_PLUGIN_API_KEY=${NATS_PLUGIN_API_KEY}
     volumes:
       - sidecar-data:/app/data

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omnixal/openclaw-nats-plugin",
-  "version": "0.2.10",
+  "version": "0.2.12",
   "description": "NATS JetStream event-driven plugin for OpenClaw",
   "license": "MIT",
   "type": "module",

package/plugins/nats-context-engine/index.ts

@@ -78,6 +78,52 @@ export default function (api: any) {
     }, { priority: 8 });
   }, { priority: 99 });
 
+  // ── Gateway stop ───────────────────────────────────────────────
+
+  api.on('gateway_stop', (event: any) => {
+    void publishToSidecar('agent.events.gateway.stopped', {
+      reason: event.reason,
+      timestamp: new Date().toISOString(),
+    });
+  }, { priority: 99 });
+
+  // ── Message received ─────────────────────────────────────────────
+
+  api.on('message_received', (event: any) => {
+    void publishToSidecar('agent.events.message.received', {
+      from: event.from,
+      content: event.content,
+      metadata: event.metadata,
+      timestamp: new Date().toISOString(),
+    });
+  }, { priority: 99 });
+
+  // ── LLM output ───────────────────────────────────────────────────
+
+  api.on('llm_output', (event: any) => {
+    void publishToSidecar('agent.events.llm.output', {
+      sessionKey: event.sessionId,
+      runId: event.runId,
+      provider: event.provider,
+      model: event.model,
+      usage: event.usage,
+      timestamp: new Date().toISOString(),
+    });
+  }, { priority: 99 });
+
+  // ── Subagent spawning ────────────────────────────────────────────
+
+  api.on('subagent_spawning', (event: any) => {
+    void publishToSidecar('agent.events.subagent.spawning', {
+      childSessionKey: event.childSessionKey,
+      agentId: event.agentId,
+      label: event.label,
+      mode: event.mode,
+      timestamp: new Date().toISOString(),
+    });
+    return { status: 'ok' };
+  }, { priority: 99 });
+
   // ── Agent Tools ─────────────────────────────────────────────────
 
   const SIDECAR_URL = process.env.NATS_SIDECAR_URL || 'http://127.0.0.1:3104';

package/sidecar/bun.lock

@@ -10,6 +10,7 @@
         "@onebun/envs": "^0.2.2",
         "@onebun/logger": "^0.2.1",
         "@onebun/nats": "^0.2.6",
+        "@onebun/requests": "^0.2.1",
         "arktype": "^2.2.0",
         "ulid": "^2.3.0",
       },

package/sidecar/package.json

@@ -11,7 +11,7 @@
     "typecheck": "bunx tsc --noEmit",
     "db:generate": "bunx onebun-drizzle generate",
     "db:push": "bunx onebun-drizzle push",
-    "db:studio": "bunx onebun-drizzle studio",
+    "db:studio": "bunx onebun-drizzle studio"
   },
   "dependencies": {
     "@onebun/core": "^0.2.15",
@@ -19,6 +19,7 @@
     "@onebun/envs": "^0.2.2",
     "@onebun/logger": "^0.2.1",
     "@onebun/nats": "^0.2.6",
+    "@onebun/requests": "^0.2.1",
     "arktype": "^2.2.0",
     "ulid": "^2.3.0"
   },

package/sidecar/src/config.ts

@@ -16,8 +16,8 @@ export const envSchema = {
     maxReconnectAttempts: Env.number({ default: -1, env: 'NATS_MAX_RECONNECT_ATTEMPTS' }),
   },
   gateway: {
-    wsUrl: Env.string({ default: 'ws://localhost:18789', env: 'OPENCLAW_WS_URL' }),
-    token: Env.string({ default: '', env: 'OPENCLAW_DEVICE_TOKEN' }),
+    url: Env.string({ default: 'http://localhost:18789', env: 'OPENCLAW_GATEWAY_URL' }),
+    hookToken: Env.string({ default: '', env: 'OPENCLAW_HOOK_TOKEN' }),
   },
   consumer: {
     name: Env.string({ default: 'openclaw-main', env: 'NATS_CONSUMER_NAME' }),

package/sidecar/src/consumer/consumer.controller.ts

@@ -58,14 +58,8 @@ export class ConsumerController extends BaseController {
           try {
             const injectStart = performance.now();
             await this.gatewayClient.inject({
-              target: route.target,
               message: this.formatMessage(envelope),
-              metadata: {
-                source: 'nats',
-                eventId: envelope.id,
-                subject: envelope.subject,
-                priority: (ctx.enrichments['priority'] as number) ?? envelope.meta?.priority ?? 5,
-              },
+              eventId: envelope.id,
             });
             const lagMs = Math.round(performance.now() - injectStart);
             await this.routerService.recordDelivery(route.id, envelope.subject, lagMs);

package/sidecar/src/gateway/gateway-client.service.ts

@@ -1,16 +1,9 @@
-import { Service, BaseService, type OnModuleInit, type OnModuleDestroy } from '@onebun/core';
-import path from 'node:path';
-import { loadOrCreateIdentity, publicKeyToBase64Url, signChallenge, type DeviceIdentity } from './device-identity';
+import { Service, BaseService, type OnModuleInit } from '@onebun/core';
+import { HttpClient, isErrorResponse } from '@onebun/requests';
 
 export interface GatewayInjectPayload {
-  target: string;
   message: string;
-  metadata?: {
-    source: 'nats';
-    eventId: string;
-    subject: string;
-    priority: number;
-  };
+  eventId?: string;
 }
 
 export class GatewayRpcError extends Error {
@@ -24,305 +17,52 @@ export class GatewayRpcError extends Error {
   }
 }
 
-interface PendingRequest {
-  resolve: () => void;
-  reject: (err: Error) => void;
-  timer: Timer;
-}
-
-const RPC_TIMEOUT_MS = 10_000;
-
 @Service()
-export class GatewayClientService extends BaseService implements OnModuleInit, OnModuleDestroy {
-  private ws: WebSocket | null = null;
-  private connected = false;
-  private connectSent = false;
-  private reconnectAttempt = 0;
-  private reconnectTimer: Timer | null = null;
+export class GatewayClientService extends BaseService implements OnModuleInit {
+  private client!: HttpClient;
+  private configured = false;
   private requestId = 0;
-  private wsUrl!: string;
-  private token!: string;
-  private identity!: DeviceIdentity;
-  private publicKeyBase64Url!: string;
-  private challengeNonce = '';
-  private pendingRequests = new Map<string, PendingRequest>();
 
   async onModuleInit(): Promise<void> {
-    this.wsUrl = this.config.get('gateway.wsUrl');
-    this.token = this.config.get('gateway.token');
-    if (this.wsUrl && this.token) {
-      const dbPath = this.config.get('database.url');
-      const identityPath = path.join(path.dirname(dbPath), 'device-identity.json');
-      this.identity = loadOrCreateIdentity(identityPath);
-      this.publicKeyBase64Url = publicKeyToBase64Url(this.identity.publicKeyPem);
-      this.logger.info('Device identity loaded', { deviceId: this.identity.deviceId });
-      this.connect();
-    } else {
-      this.logger.warn('Gateway WebSocket not configured — skipping connection (need wsUrl + deviceToken)');
-    }
-  }
-
-  private connect(): void {
-    try {
-      this.connectSent = false;
-      this.ws = new WebSocket(this.wsUrl);
-
-      this.ws.onopen = () => {
-        this.reconnectAttempt = 0;
-        this.logger.info('Gateway WebSocket opened, waiting for connect.challenge');
-      };
-
-      this.ws.onmessage = (event) => {
-        this.handleMessage(String(event.data));
-      };
-
-      this.ws.onclose = () => {
-        this.connected = false;
-        this.connectSent = false;
-        // Reject all in-flight requests immediately — don't make callers wait for timeout
-        for (const [id, pending] of this.pendingRequests) {
-          clearTimeout(pending.timer);
-          pending.reject(new Error('Gateway WebSocket closed'));
-        }
-        this.pendingRequests.clear();
-        this.scheduleReconnect();
-      };
-
-      this.ws.onerror = () => {
-        this.logger.warn('Gateway WebSocket error');
-        this.connected = false;
-      };
-    } catch (err) {
-      this.logger.warn('Failed to connect to Gateway WebSocket', err);
-      this.scheduleReconnect();
-    }
-  }
-
-  private handleMessage(data: string): void {
-    let frame: any;
-    try {
-      frame = JSON.parse(data);
-    } catch {
-      this.logger.warn(`Failed to parse WebSocket message: ${data.slice(0, 200)}`);
-      return;
-    }
-
-    // Server challenge — respond with connect frame
-    if (frame.type === 'event' && frame.event === 'connect.challenge') {
-      this.challengeNonce = frame.payload?.nonce ?? '';
-      this.logger.debug('Received connect.challenge from server', { hasNonce: !!this.challengeNonce });
-      this.sendConnectFrame();
-      return;
-    }
-
-    // Some gateway versions send an event before challenge; treat any pre-connect event as trigger
-    if (!this.connectSent && frame.type === 'event') {
-      this.logger.debug('Received event before connect sent, sending connect frame');
-      this.sendConnectFrame();
-      return;
-    }
-
-    // Successful connect response — must be hello-ok
-    if (frame.type === 'res' && frame.ok === true) {
-      const payload = frame.payload;
-      if (payload?.type === 'hello-ok') {
-        if (!this.connected) {
-          this.connected = true;
-          const grantedScopes = payload.auth?.scopes ?? [];
-          const serverVersion = payload.server?.version ?? 'unknown';
-          this.logger.info('OpenClaw handshake complete', {
-            protocol: payload.protocol,
-            serverVersion,
-            grantedScopes,
-            connId: payload.server?.connId,
-          });
-          if (grantedScopes.length > 0 && !grantedScopes.includes('operator.write')) {
-            this.logger.error(
-              `Gateway did NOT grant operator.write scope! Granted: [${grantedScopes.join(', ')}]. ` +
-              'Message delivery will fail. Rotate the device token with --scope operator.write',
-            );
-          }
-        }
-        return;
-      }
-      // Regular RPC ok response (e.g. for inject calls)
-      this.logger.debug('Received RPC ok response', { id: frame.id });
-      this.resolvePending(frame.id);
-      return;
-    }
-
-    // Error response
-    if (frame.type === 'res' && frame.ok === false) {
-      const errorCode = frame.error?.code ?? frame.error?.errorCode ?? 'UNKNOWN';
-      const errorMessage = frame.error?.message ?? frame.error?.errorMessage ?? 'Unknown gateway error';
-      this.logger.error('Gateway RPC error', { id: frame.id, errorCode, errorMessage });
-
-      // If this is a connect error, close and reconnect
-      if (frame.id?.startsWith('connect-')) {
-        this.logger.error(`Gateway rejected connection: ${errorCode} — ${errorMessage}`);
-        this.connected = false;
-        this.connectSent = false;
-        this.ws?.close();
-        return;
-      }
-
-      this.rejectPending(frame.id, new GatewayRpcError(frame.id, String(errorCode), String(errorMessage)));
-    }
-  }
-
-  private sendConnectFrame(): void {
-    if (!this.ws || this.ws.readyState !== WebSocket.OPEN || this.connectSent) return;
-    this.connectSent = true;
-
-    const signedAt = Date.now();
-    const scopes = ['operator.read', 'operator.write'];
-    const client = {
-      id: 'gateway-client' as const,
-      displayName: 'nats-sidecar',
-      version: '1.0.0',
-      platform: 'linux',
-      mode: 'backend' as const,
-    };
-
-    const signature = signChallenge(this.identity.privateKeyPem, {
-      deviceId: this.identity.deviceId,
-      clientId: client.id,
-      clientMode: client.mode,
-      role: 'operator',
-      scopes,
-      signedAtMs: signedAt,
-      token: this.token,
-      nonce: this.challengeNonce,
-      platform: client.platform,
-    });
-
-    this.logger.info('Sending connect frame with device identity', {
-      deviceId: this.identity.deviceId,
-    });
-
-    try {
-      this.send({
-        type: 'req',
-        id: `connect-${++this.requestId}`,
-        method: 'connect',
-        params: {
-          minProtocol: 3,
-          maxProtocol: 3,
-          client,
-          role: 'operator',
-          scopes,
-          caps: [],
-          commands: [],
-          permissions: {},
-          auth: { token: this.token },
-          device: {
-            id: this.identity.deviceId,
-            publicKey: this.publicKeyBase64Url,
-            signature,
-            signedAt,
-            nonce: this.challengeNonce,
-          },
-          locale: 'en-US',
-          userAgent: 'nats-sidecar/1.0.0',
+    const gatewayUrl = this.config.get('gateway.url');
+    const hookToken = this.config.get('gateway.hookToken');
+
+    if (gatewayUrl && hookToken) {
+      this.client = new HttpClient({
+        baseUrl: gatewayUrl,
+        timeout: 10_000,
+        auth: { type: 'bearer', token: hookToken },
+        retries: {
+          max: 2,
+          backoff: 'exponential',
+          delay: 500,
+          retryOn: [502, 503, 504],
         },
       });
-    } catch (err) {
-      this.logger.error('Failed to send connect frame', err);
-      this.connectSent = false;
-    }
-  }
-
-  private send(frame: unknown): void {
-    if (this.ws?.readyState !== WebSocket.OPEN) {
-      throw new Error('WebSocket is not open');
-    }
-    try {
-      this.ws.send(JSON.stringify(frame));
-    } catch (err) {
-      this.connected = false;
-      throw new Error(`WebSocket send failed: ${err instanceof Error ? err.message : String(err)}`);
+      this.configured = true;
+      this.logger.info('Gateway webhook configured', { url: gatewayUrl });
+    } else {
+      this.logger.warn('Gateway webhook not configured — need url + hookToken');
     }
   }
 
-  private scheduleReconnect(): void {
-    if (this.reconnectTimer) return;
-    const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempt), 30_000);
-    this.reconnectAttempt++;
-    this.logger.debug(`Reconnecting to Gateway in ${delay}ms (attempt ${this.reconnectAttempt})`);
-    this.reconnectTimer = setTimeout(() => {
-      this.reconnectTimer = null;
-      this.connect();
-    }, delay);
-  }
-
   async inject(payload: GatewayInjectPayload): Promise<void> {
-    if (!this.isAlive()) {
-      throw new Error('Gateway WebSocket not connected');
+    if (!this.configured) {
+      throw new Error('Gateway webhook not configured');
     }
     const id = `rpc-${++this.requestId}`;
-    const promise = this.trackRequest(id);
-    this.send({
-      type: 'req',
-      id,
-      method: 'send',
-      params: {
-        target: payload.target,
-        message: payload.message,
-        metadata: payload.metadata,
-        idempotencyKey: payload.metadata?.eventId ?? String(this.requestId),
-      },
-    });
-    return promise;
-  }
 
-  private trackRequest(id: string): Promise<void> {
-    return new Promise<void>((resolve, reject) => {
-      const timer = setTimeout(() => {
-        this.pendingRequests.delete(id);
-        reject(new Error(`Gateway RPC timeout after ${RPC_TIMEOUT_MS}ms [${id}]`));
-      }, RPC_TIMEOUT_MS);
-      this.pendingRequests.set(id, { resolve, reject, timer });
+    const response = await this.client.post('/hooks/wake', {
+      text: payload.message,
+      mode: 'now',
     });
-  }
-
-  private resolvePending(id: string): void {
-    const pending = this.pendingRequests.get(id);
-    if (pending) {
-      clearTimeout(pending.timer);
-      this.pendingRequests.delete(id);
-      pending.resolve();
-    }
-  }
 
-  private rejectPending(id: string, err: Error): void {
-    const pending = this.pendingRequests.get(id);
-    if (pending) {
-      clearTimeout(pending.timer);
-      this.pendingRequests.delete(id);
-      pending.reject(err);
+    if (isErrorResponse(response)) {
+      throw new GatewayRpcError(id, String(response.code), response.message ?? response.error);
     }
   }
 
   isAlive(): boolean {
-    return this.connected && this.ws?.readyState === WebSocket.OPEN;
-  }
-
-  async onModuleDestroy(): Promise<void> {
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-    // Reject all pending requests
-    for (const [id, pending] of this.pendingRequests) {
-      clearTimeout(pending.timer);
-      pending.reject(new Error('Gateway client shutting down'));
-    }
-    this.pendingRequests.clear();
-    if (this.ws) {
-      this.ws.close();
-      this.ws = null;
-    }
-    this.connected = false;
-    this.connectSent = false;
+    return this.configured;
   }
 }

package/sidecar/src/health/health.service.ts

@@ -44,7 +44,7 @@ export class HealthService extends BaseService {
       },
       gateway: {
         connected: this.gateway.isAlive(),
-        url: this.config.get('gateway.wsUrl'),
+        url: this.config.get('gateway.url'),
       },
       pendingCount,
       uptimeSeconds: Math.floor((Date.now() - this.startedAt) / 1000),

package/sidecar/src/logs/log.repository.ts

@@ -56,7 +56,7 @@ export class LogRepository extends BaseService {
       .select({ count: sql<number>`count(*)` })
       .from(executionLogs)
       .where(this.buildWhereConditions(filters));
-    return result[0]?.count ?? 0;
+    return (result[0] as unknown as { count: number })?.count ?? 0;
   }
 
   async findRecent(limit: number = 20): Promise<DbExecutionLog[]> {

package/sidecar/src/logs/log.service.ts

@@ -58,7 +58,7 @@ export class LogService extends BaseService {
     }
   }
 
-  async logError(entityType: 'route' | 'cron', entityId: string, subject: string, error: unknown): Promise<void> {
+  async logError(entityType: 'route' | 'cron' | 'timer', entityId: string, subject: string, error: unknown): Promise<void> {
     try {
       const detail = error instanceof Error
         ? JSON.stringify({ message: error.message, stack: error.stack })

package/sidecar/src/pending/pending.repository.ts

@@ -49,7 +49,7 @@ export class PendingRepository extends BaseService {
       .select({ count: sql<number>`count(*)` })
       .from(pendingEvents)
       .where(isNull(pendingEvents.deliveredAt));
-    return result[0]?.count ?? 0;
+    return (result[0] as unknown as { count: number })?.count ?? 0;
   }
 
   async cleanup(ttlSeconds: number): Promise<number> {

package/sidecar/src/router/router.repository.ts

@@ -82,6 +82,6 @@ export class RouterRepository extends BaseService {
     const result = await this.db
       .select({ count: sql<number>`count(*)` })
       .from(eventRoutes);
-    return result[0]?.count ?? 0;
+    return (result[0] as unknown as { count: number })?.count ?? 0;
   }
 }