openbroker 1.0.61 → 1.0.62

package/SKILL.md

@@ -4,7 +4,7 @@ description: Hyperliquid trading plugin with background position monitoring and
 license: MIT
 compatibility: Requires Node.js 22+, network access to api.hyperliquid.xyz
 homepage: https://www.npmjs.com/package/openbroker
-metadata: {"author": "monemetrics", "version": "1.0.61", "openclaw": {"requires": {"bins": ["openbroker"], "env": ["HYPERLIQUID_PRIVATE_KEY"]}, "primaryEnv": "HYPERLIQUID_PRIVATE_KEY", "install": [{"id": "node", "kind": "node", "package": "openbroker", "bins": ["openbroker"], "label": "Install openbroker (npm)"}]}}
+metadata: {"author": "monemetrics", "version": "1.0.62", "openclaw": {"requires": {"bins": ["openbroker"], "env": ["HYPERLIQUID_PRIVATE_KEY"]}, "primaryEnv": "HYPERLIQUID_PRIVATE_KEY", "install": [{"id": "node", "kind": "node", "package": "openbroker", "bins": ["openbroker"], "label": "Install openbroker (npm)"}]}}
 allowed-tools: ob_account ob_positions ob_funding ob_markets ob_search ob_spot ob_fills ob_orders ob_order_status ob_fees ob_candles ob_funding_history ob_trades ob_rate_limit ob_funding_scan ob_buy ob_sell ob_limit ob_trigger ob_tpsl ob_cancel ob_twap ob_bracket ob_chase ob_watcher_status ob_auto_run ob_auto_stop ob_auto_list Bash(openbroker:*)
 ---
 
@@ -546,6 +546,7 @@ export default function(api) {
 | `api.state.set(key, value)` | Set a persisted value |
 | `api.state.delete(key)` | Delete a persisted value |
 | `api.state.clear()` | Clear all state |
+| `api.publish(message, options?)` | Send a message to the OpenClaw agent via webhook. Triggers an agent turn — the agent receives the message and can notify the user, take action, etc. Returns `true` if delivered. Options: `{ name?, wakeMode?, deliver?, channel? }` |
 | `api.log.info/warn/error/debug(msg)` | Structured logger |
 | `api.utils` | `roundPrice`, `roundSize`, `sleep`, `normalizeCoin`, `formatUsd`, `annualizeFundingRate` |
 | `api.id` | Automation ID (filename or `--id` flag) |
@@ -652,6 +653,47 @@ export default function(api) {
 }
 ```
 
+### Publishing to the Agent (Webhooks)
+
+Use `api.publish()` to send messages back to the OpenClaw agent. This triggers an agent turn — the agent receives the message and can notify the user via their preferred channel, take trading actions, or log the event.
+
+```typescript
+// Simple notification
+await api.publish(`ETH broke above $4000 — current price: $${price}`);
+
+// With options
+await api.publish(`Margin at ${pct}% — positions at risk`, {
+  name: 'margin-alert',           // appears in logs
+  wakeMode: 'now',                // 'now' (default) or 'next-heartbeat'
+  channel: 'slack',               // target channel (optional)
+});
+```
+
+`api.publish()` returns `true` if delivered, `false` if webhooks are not configured (no hooks token). It requires `OPENCLAW_HOOKS_TOKEN` to be set (automatically configured when running as an OpenClaw plugin).
+
+**Example: Price alert automation with publish**
+```typescript
+// ~/.openbroker/automations/price-alert.ts
+export default function(api) {
+  const COIN = 'ETH';
+  const THRESHOLD = 4000;
+
+  api.on('price_change', async ({ coin, newPrice, changePct }) => {
+    if (coin !== COIN) return;
+
+    const crossed = api.state.get<boolean>('crossed', false);
+    if (!crossed && newPrice >= THRESHOLD) {
+      api.state.set('crossed', true);
+      await api.publish(
+        `${COIN} crossed above $${THRESHOLD}! Price: $${newPrice.toFixed(2)} (+${changePct.toFixed(2)}%)`,
+      );
+    } else if (crossed && newPrice < THRESHOLD) {
+      api.state.set('crossed', false);
+    }
+  });
+}
+```
+
 ### Running Automations
 
 **CLI:**
@@ -680,9 +722,11 @@ openbroker auto status                      # Show running automations
 - Always test with `--dry` first before live trading
 - Use `api.state` to track position state across restarts
 - Use `api.onStop()` to clean up — close positions, cancel orders
+- Use `api.publish()` to send alerts/events back to the OpenClaw agent — do NOT manually construct webhook requests
 - The runtime catches errors per handler — one failing handler won't crash others
 - Scripts are loaded from `~/.openbroker/automations/` by name, or from any absolute path
 - All trading commands support HIP-3 assets (`api.client.marketOrder('xyz:CL', true, 1)`)
+- Automations persist across gateway restarts — they are automatically restarted when the gateway comes back up
 
 ## Risk Warning
 

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "openbroker",
   "name": "OpenBroker — Hyperliquid Trading",
-  "version": "1.0.61",
+  "version": "1.0.62",
   "description": "Trade on Hyperliquid DEX with background position monitoring",
   "configSchema": {
     "type": "object",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openbroker",
-  "version": "1.0.61",
+  "version": "1.0.62",
   "description": "Hyperliquid trading CLI - execute orders, manage positions, and run trading strategies",
   "type": "module",
   "bin": {

package/scripts/auto/cli.ts

@@ -2,7 +2,8 @@
 
 import { parseArgs } from '../core/utils.js';
 import { resolveScriptPath, listAutomations, ensureAutomationsDir } from './loader.js';
-import { startAutomation, getRunningAutomations } from './runtime.js';
+import { startAutomation, getRunningAutomations, getRegisteredAutomations } from './runtime.js';
+import { unregisterAutomation, cleanRegistry } from './registry.js';
 
 function printUsage() {
   console.log(`
@@ -10,8 +11,10 @@ OpenBroker Automations — event-driven trading scripts
 
 Usage:
   openbroker auto run <script> [options]    Run an automation script
+  openbroker auto stop <id>                 Unregister an automation (won't restart)
   openbroker auto list                      List available automations
   openbroker auto status                    Show running automations
+  openbroker auto clean                     Remove stale entries from registry
 
 Options (for run):
   --dry              Intercept write methods (no real trades)
@@ -100,24 +103,82 @@ function listCommand() {
 }
 
 function statusCommand() {
-  const running = getRunningAutomations();
+  // Show in-process automations (if any running in this process)
+  const inProcess = getRunningAutomations();
 
-  if (running.length === 0) {
+  // Show all registered automations from file-based registry (cross-process)
+  const registered = getRegisteredAutomations();
+
+  if (inProcess.length === 0 && registered.length === 0) {
     console.log('No automations running');
     return;
   }
 
-  console.log('Running automations:\n');
-  for (const a of running) {
-    const uptime = Math.round((Date.now() - a.startedAt.getTime()) / 1000);
-    console.log(`  ${a.id}`);
-    console.log(`    Script:  ${a.scriptPath}`);
-    console.log(`    Uptime:  ${uptime}s`);
-    console.log(`    Polls:   ${a.pollCount}`);
-    console.log(`    Events:  ${a.eventsEmitted}`);
-    console.log(`    Dry run: ${a.dryRun}`);
-    console.log('');
+  // Show in-process automations with live stats
+  if (inProcess.length > 0) {
+    console.log('Running in this process:\n');
+    for (const a of inProcess) {
+      const uptime = Math.round((Date.now() - a.startedAt.getTime()) / 1000);
+      console.log(`  ${a.id}`);
+      console.log(`    Script:  ${a.scriptPath}`);
+      console.log(`    Uptime:  ${uptime}s`);
+      console.log(`    Polls:   ${a.pollCount}`);
+      console.log(`    Events:  ${a.eventsEmitted}`);
+      console.log(`    Dry run: ${a.dryRun}`);
+      console.log('');
+    }
+  }
+
+  // Show all registered automations (may include ones from other processes)
+  const external = registered.filter(
+    r => !inProcess.some(ip => ip.id === r.id),
+  );
+
+  if (external.length > 0) {
+    if (inProcess.length > 0) console.log('Other processes:\n');
+    else console.log('Registered automations:\n');
+
+    for (const a of external) {
+      const uptime = a.status === 'running'
+        ? `${Math.round((Date.now() - new Date(a.startedAt).getTime()) / 1000)}s`
+        : '-';
+      console.log(`  ${a.id}`);
+      console.log(`    Script:  ${a.scriptPath}`);
+      console.log(`    Status:  ${a.status}${a.error ? ` (${a.error})` : ''}`);
+      console.log(`    PID:     ${a.pid}`);
+      console.log(`    Uptime:  ${uptime}`);
+      console.log(`    Dry run: ${a.dryRun}`);
+      console.log('');
+    }
+  }
+}
+
+function stopCommand(positional: string[]) {
+  const id = positional[0];
+  if (!id) {
+    console.error('Error: automation ID required');
+    console.log('Usage: openbroker auto stop <id>');
+    process.exit(1);
+  }
+
+  // Check if running in this process
+  const inProcess = getRunningAutomations();
+  const running = inProcess.find(a => a.id === id);
+  if (running) {
+    running.stop().then(() => {
+      console.log(`Stopped and unregistered: ${id}`);
+    });
+    return;
   }
+
+  // Otherwise just remove from file registry (prevents restart)
+  unregisterAutomation(id);
+  console.log(`Unregistered: ${id} (will not restart on next gateway start)`);
+}
+
+function cleanCommand() {
+  cleanRegistry();
+  console.log('Cleaned stale entries from registry');
 }
 
 async function main() {
@@ -153,12 +214,18 @@ async function main() {
     case 'run':
       await runCommand(args, positional);
       break;
+    case 'stop':
+      stopCommand(positional);
+      break;
     case 'list':
       listCommand();
       break;
     case 'status':
       statusCommand();
       break;
+    case 'clean':
+      cleanCommand();
+      break;
     default:
       console.error(`Unknown subcommand: ${subcommand}`);
       console.log('Run "openbroker auto --help" for usage');

package/scripts/auto/registry.ts

@@ -0,0 +1,118 @@
+// File-based automation registry — tracks desired state across processes
+// Persisted at ~/.openbroker/state/_registry.json so both CLI and plugin
+// can see which automations should be running.
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import path from 'path';
+import os from 'os';
+
+const STATE_DIR = path.join(os.homedir(), '.openbroker', 'state');
+const REGISTRY_FILE = path.join(STATE_DIR, '_registry.json');
+
+export interface RegistryEntry {
+  id: string;
+  scriptPath: string;
+  dryRun: boolean;
+  verbose: boolean;
+  pollIntervalMs: number;
+  startedAt: string;        // ISO timestamp
+  pid: number;              // Process that started it
+  status: 'running' | 'stopped' | 'error';
+  error?: string;           // Last error message if status is 'error'
+}
+
+function ensureDir(): void {
+  mkdirSync(STATE_DIR, { recursive: true });
+}
+
+function readRegistry(): RegistryEntry[] {
+  if (!existsSync(REGISTRY_FILE)) return [];
+  try {
+    const raw = readFileSync(REGISTRY_FILE, 'utf-8');
+    const entries = JSON.parse(raw);
+    return Array.isArray(entries) ? entries : [];
+  } catch {
+    return [];
+  }
+}
+
+function writeRegistry(entries: RegistryEntry[]): void {
+  ensureDir();
+  writeFileSync(REGISTRY_FILE, JSON.stringify(entries, null, 2));
+}
+
+/** Check if a process is still alive */
+function isProcessAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0); // Signal 0 = just check, don't kill
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Register an automation as running */
+export function registerAutomation(entry: Omit<RegistryEntry, 'status' | 'pid' | 'startedAt'>): void {
+  const entries = readRegistry();
+
+  // Remove any existing entry with the same id
+  const filtered = entries.filter(e => e.id !== entry.id);
+
+  filtered.push({
+    ...entry,
+    status: 'running',
+    pid: process.pid,
+    startedAt: new Date().toISOString(),
+  });
+
+  writeRegistry(filtered);
+}
+
+/** Unregister an automation (remove from desired state) */
+export function unregisterAutomation(id: string): void {
+  const entries = readRegistry();
+  writeRegistry(entries.filter(e => e.id !== id));
+}
+
+/** Mark an automation as errored (keep in registry for visibility) */
+export function markAutomationError(id: string, error: string): void {
+  const entries = readRegistry();
+  const entry = entries.find(e => e.id === id);
+  if (entry) {
+    entry.status = 'error';
+    entry.error = error;
+    writeRegistry(entries);
+  }
+}
+
+/** Get all registered automations, with stale process detection */
+export function getRegisteredAutomations(): RegistryEntry[] {
+  const entries = readRegistry();
+  let dirty = false;
+
+  for (const entry of entries) {
+    if (entry.status === 'running' && !isProcessAlive(entry.pid)) {
+      // Process died without cleanup — mark as stopped
+      entry.status = 'stopped';
+      dirty = true;
+    }
+  }
+
+  if (dirty) writeRegistry(entries);
+  return entries;
+}
+
+/** Get automations that should be restarted (were running when process died) */
+export function getAutomationsToRestart(): RegistryEntry[] {
+  const entries = getRegisteredAutomations();
+  // Return entries that were running but whose process is no longer alive
+  // (getRegisteredAutomations already marked them as 'stopped')
+  // We want entries that are 'stopped' — they need to be restarted
+  return entries.filter(e => e.status === 'stopped');
+}
+
+/** Clean up the registry — remove stopped/errored entries */
+export function cleanRegistry(): void {
+  const entries = readRegistry();
+  writeRegistry(entries.filter(e => e.status === 'running' && isProcessAlive(e.pid)));
+}

package/scripts/auto/runtime.ts

@@ -11,12 +11,14 @@ import {
 } from '../core/utils.js';
 import { AutomationEventBus } from './events.js';
 import { loadAutomation } from './loader.js';
+import { registerAutomation, unregisterAutomation, markAutomationError, getRegisteredAutomations as getRegisteredFromFile } from './registry.js';
 import type {
   AutomationAPI,
   AutomationLogger,
   AutomationState,
   AutomationSnapshot,
   PositionSnapshot,
+  PublishOptions,
   ScheduledTask,
   RunningAutomation,
 } from './types.js';
@@ -167,6 +169,56 @@ async function buildSnapshot(
   };
 }
 
+// ── Publish (webhook) ───────────────────────────────────────────────
+
+function createPublish(
+  automationId: string,
+  log: AutomationLogger,
+  gatewayPort?: number,
+  hooksToken?: string,
+): (message: string, options?: PublishOptions) => Promise<boolean> {
+  return async (message: string, options?: PublishOptions): Promise<boolean> => {
+    const token = hooksToken || process.env.OPENCLAW_HOOKS_TOKEN;
+    const port = gatewayPort || parseInt(process.env.OPENCLAW_GATEWAY_PORT || '18789', 10);
+
+    if (!token) {
+      log.debug('publish() skipped — no hooks token configured (set OPENCLAW_HOOKS_TOKEN or pass hooksToken in plugin config)');
+      return false;
+    }
+
+    const body: Record<string, unknown> = {
+      message,
+      name: options?.name || `ob-auto-${automationId}`,
+      wakeMode: options?.wakeMode || 'now',
+    };
+
+    if (options?.deliver !== undefined) body.deliver = options.deliver;
+    if (options?.channel) body.channel = options.channel;
+
+    try {
+      const res = await fetch(`http://127.0.0.1:${port}/hooks/agent`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${token}`,
+        },
+        body: JSON.stringify(body),
+      });
+
+      if (!res.ok) {
+        log.warn(`publish() failed: HTTP ${res.status} ${res.statusText}`);
+        return false;
+      }
+
+      log.debug(`publish() delivered to /hooks/agent (${message.length} chars)`);
+      return true;
+    } catch (err) {
+      log.warn(`publish() error: ${err instanceof Error ? err.message : String(err)}`);
+      return false;
+    }
+  };
+}
+
 // ── Runtime ─────────────────────────────────────────────────────────
 
 export interface RuntimeOptions {
@@ -175,6 +227,10 @@ export interface RuntimeOptions {
   dryRun?: boolean;
   verbose?: boolean;
   pollIntervalMs?: number;
+  /** Gateway port for webhook delivery. Falls back to OPENCLAW_GATEWAY_PORT or 18789 */
+  gatewayPort?: number;
+  /** Hooks token for webhook auth. Falls back to OPENCLAW_HOOKS_TOKEN */
+  hooksToken?: string;
 }
 
 /** Registry of all running automations */
@@ -188,12 +244,17 @@ export function getAutomation(id: string): RunningAutomation | undefined {
   return registry.get(id);
 }
 
+/** Get all automations from file-based registry (cross-process visibility) */
+export { getRegisteredFromFile as getRegisteredAutomations };
+
 export async function startAutomation(options: RuntimeOptions): Promise<RunningAutomation> {
   const {
     scriptPath,
     dryRun = false,
     verbose = false,
     pollIntervalMs = 10_000,
+    gatewayPort,
+    hooksToken,
   } = options;
 
   const id = options.id || path.basename(scriptPath, '.ts');
@@ -215,6 +276,7 @@ export async function startAutomation(options: RuntimeOptions): Promise<RunningA
   const scheduledTasks: ScheduledTask[] = [];
 
   // Build the API object
+  const publish = createPublish(id, log, gatewayPort, hooksToken);
   const api: AutomationAPI = {
     client,
     utils: { roundPrice, roundSize, sleep, normalizeCoin, formatUsd, formatPercent, annualizeFundingRate },
@@ -223,6 +285,7 @@ export async function startAutomation(options: RuntimeOptions): Promise<RunningA
     onStart: (handler) => startHooks.push(handler),
     onStop: (handler) => stopHooks.push(handler),
     onError: (handler) => errorHooks.push(handler),
+    publish,
     state,
     log,
     id,
@@ -416,7 +479,7 @@ export async function startAutomation(options: RuntimeOptions): Promise<RunningA
   await poll();
 
   // Stop function
-  async function stop() {
+  async function stop(opts?: { persist?: boolean }) {
     if (stopped) return;
     stopped = true;
     clearInterval(timer);
@@ -429,6 +492,12 @@ export async function startAutomation(options: RuntimeOptions): Promise<RunningA
 
     eventBus.removeAll();
     registry.delete(id);
+
+    // persist defaults to true — fully remove from file registry.
+    // When false (gateway shutdown), keep the entry so it restarts next time.
+    if (opts?.persist !== false) {
+      unregisterAutomation(id);
+    }
     log.info(`Stopped (${pollCount} polls, ${eventsEmitted} events)`);
   }
 
@@ -443,5 +512,15 @@ export async function startAutomation(options: RuntimeOptions): Promise<RunningA
   };
 
   registry.set(id, entry);
+
+  // Persist to file-based registry so other processes (CLI, plugin) can see it
+  registerAutomation({
+    id,
+    scriptPath,
+    dryRun,
+    verbose,
+    pollIntervalMs,
+  });
+
   return entry;
 }

package/scripts/auto/types.ts

@@ -52,6 +52,19 @@ export interface AutomationLogger {
   debug(message: string): void;
 }
 
+// ── Publish (webhook) ───────────────────────────────────────────────
+
+export interface PublishOptions {
+  /** Human-readable name for the hook (appears in logs). Default: "ob-auto-<id>" */
+  name?: string;
+  /** Wake mode: "now" triggers immediate agent turn, "next-heartbeat" queues. Default: "now" */
+  wakeMode?: 'now' | 'next-heartbeat';
+  /** Whether to deliver the agent response to messaging channels. Default: true */
+  deliver?: boolean;
+  /** Target channel (e.g. "slack", "telegram", "last"). Default: agent decides */
+  channel?: string;
+}
+
 // ── Core API ────────────────────────────────────────────────────────
 
 export interface AutomationAPI {
@@ -84,6 +97,17 @@ export interface AutomationAPI {
   /** Called when a handler throws. The error is already logged — use this for recovery logic. */
   onError(handler: (error: Error) => void | Promise<void>): void;
 
+  /**
+   * Publish a message to the OpenClaw agent via webhook.
+   * Sends to POST /hooks/agent on the local gateway, triggering an agent turn.
+   * The agent receives the message and can act on it (notify user, trade, etc.).
+   *
+   * @param message — The message string the agent will receive
+   * @param options — Optional: name, wakeMode, deliver, channel
+   * @returns true if delivered, false if webhook is not configured
+   */
+  publish(message: string, options?: PublishOptions): Promise<boolean>;
+
   /** Persisted key-value state (~/.openbroker/state/<id>.json) */
   state: AutomationState;
 
@@ -134,5 +158,10 @@ export interface RunningAutomation {
   pollCount: number;
   eventsEmitted: number;
   dryRun: boolean;
-  stop: () => Promise<void>;
+  /**
+   * Stop the automation.
+   * @param opts.persist If false, keep the entry in the file registry so it
+   *   restarts when the gateway comes back up. Default: true (fully remove).
+   */
+  stop: (opts?: { persist?: boolean }) => Promise<void>;
 }

package/scripts/plugin/index.ts

@@ -1,11 +1,78 @@
 // OpenClaw Plugin Entry Point for OpenBroker
 
-import type { OpenClawPluginApi, OpenBrokerPluginConfig } from './types.js';
+import type { OpenClawPluginApi, OpenBrokerPluginConfig, PluginLogger } from './types.js';
 import { applyConfigBridge } from './config-bridge.js';
 import { PositionWatcher } from './watcher.js';
 import { createTools } from './tools.js';
 import { registerCliCommands } from './cli.js';
 
+/**
+ * AutomationService — restarts automations from the file-based registry
+ * when the OpenClaw gateway starts. When the gateway process dies,
+ * automations die with it. On next start, this service reads the registry
+ * and restarts any automations that were previously running.
+ */
+function createAutomationService(logger: PluginLogger, gatewayPort?: number, hooksToken?: string) {
+  return {
+    id: 'openbroker-automations',
+
+    async start() {
+      const { getAutomationsToRestart } = await import('../auto/registry.js');
+      const entries = getAutomationsToRestart();
+
+      if (entries.length === 0) {
+        logger.debug('No automations to restart');
+        return;
+      }
+
+      logger.info(`Restarting ${entries.length} automation(s) from previous session`);
+
+      const { startAutomation } = await import('../auto/runtime.js');
+      const { resolveScriptPath } = await import('../auto/loader.js');
+
+      for (const entry of entries) {
+        try {
+          // Verify script still exists before restarting
+          const scriptPath = resolveScriptPath(entry.scriptPath);
+          await startAutomation({
+            scriptPath,
+            id: entry.id,
+            dryRun: entry.dryRun,
+            verbose: entry.verbose,
+            pollIntervalMs: entry.pollIntervalMs,
+            gatewayPort,
+            hooksToken,
+          });
+          logger.info(`Restarted automation: ${entry.id}`);
+        } catch (err) {
+          const msg = err instanceof Error ? err.message : String(err);
+          logger.error(`Failed to restart automation "${entry.id}": ${msg}`);
+
+          // Mark as errored in registry so it doesn't retry forever
+          const { markAutomationError } = await import('../auto/registry.js');
+          markAutomationError(entry.id, msg);
+        }
+      }
+    },
+
+    async stop() {
+      // Stop all in-process automations but keep them in the file registry
+      // so they restart when the gateway comes back up
+      const { getRunningAutomations } = await import('../auto/runtime.js');
+      const running = getRunningAutomations();
+
+      for (const auto of running) {
+        try {
+          await auto.stop({ persist: false }); // Keep in registry for restart
+          logger.info(`Stopped automation for gateway shutdown: ${auto.id}`);
+        } catch (err) {
+          logger.error(`Error stopping automation "${auto.id}": ${err instanceof Error ? err.message : String(err)}`);
+        }
+      }
+    },
+  };
+}
+
 export default {
   id: 'openbroker',
   name: 'OpenBroker — Hyperliquid Trading',
@@ -43,14 +110,23 @@ export default {
       logger.debug('OpenBroker position watcher disabled by config');
     }
 
-    // 3. Register agent tools
-    const tools = createTools(watcher);
+    // 3. Register automation restart service
+    const resolvedHooksToken = pluginConfig.hooksToken || process.env.OPENCLAW_HOOKS_TOKEN;
+    api.registerService(createAutomationService(logger, gatewayPort, resolvedHooksToken));
+    logger.debug('OpenBroker automation service registered');
+
+    // 4. Register agent tools
+    const tools = createTools({
+      watcher,
+      gatewayPort,
+      hooksToken: pluginConfig.hooksToken || process.env.OPENCLAW_HOOKS_TOKEN,
+    });
     for (const tool of tools) {
       api.registerTool(tool);
     }
     logger.debug(`Registered ${tools.length} OpenBroker agent tools`);
 
-    // 4. Register CLI commands
+    // 5. Register CLI commands
     registerCliCommands(api, watcher, logger);
     logger.debug('OpenBroker CLI commands registered');
   },

package/scripts/plugin/tools.ts

@@ -18,7 +18,18 @@ function error(message: string) {
   return json({ error: message });
 }
 
-export function createTools(watcher: PositionWatcher | null): PluginTool[] {
+export interface ToolsContext {
+  watcher: PositionWatcher | null;
+  gatewayPort?: number;
+  hooksToken?: string;
+}
+
+export function createTools(watcherOrCtx: PositionWatcher | null | ToolsContext): PluginTool[] {
+  // Support both old signature (watcher only) and new (full context)
+  const ctx: ToolsContext = watcherOrCtx !== null && typeof watcherOrCtx === 'object' && 'watcher' in watcherOrCtx
+    ? watcherOrCtx
+    : { watcher: watcherOrCtx };
+  const { watcher, gatewayPort, hooksToken } = ctx;
   return [
     // ── Info Tools ──────────────────────────────────────────────
 
@@ -1326,6 +1337,8 @@ export function createTools(watcher: PositionWatcher | null): PluginTool[] {
             id: params.id ? String(params.id) : undefined,
             dryRun: params.dry === true,
             pollIntervalMs: params.poll ? Number(params.poll) : 10_000,
+            gatewayPort,
+            hooksToken,
           });
 
           return json({
@@ -1367,23 +1380,41 @@ export function createTools(watcher: PositionWatcher | null): PluginTool[] {
 
     {
       name: 'ob_auto_list',
-      description: 'List available automation scripts and running automations',
+      description: 'List available automation scripts and running automations (including those started from other processes)',
       parameters: { type: 'object', properties: {} },
       async execute() {
         const { listAutomations } = await import('../auto/loader.js');
-        const { getRunningAutomations } = await import('../auto/runtime.js');
+        const { getRunningAutomations, getRegisteredAutomations } = await import('../auto/runtime.js');
 
         const available = listAutomations();
-        const running = getRunningAutomations().map(a => ({
+
+        // In-process automations with live stats
+        const inProcess = getRunningAutomations().map(a => ({
           id: a.id,
           scriptPath: a.scriptPath,
           uptime: Math.round((Date.now() - a.startedAt.getTime()) / 1000),
           pollCount: a.pollCount,
           eventsEmitted: a.eventsEmitted,
           dryRun: a.dryRun,
+          source: 'this_process',
         }));
 
-        return json({ available, running });
+        // File-registry entries from other processes
+        const registered = getRegisteredAutomations();
+        const external = registered
+          .filter(r => !inProcess.some(ip => ip.id === r.id))
+          .map(r => ({
+            id: r.id,
+            scriptPath: r.scriptPath,
+            status: r.status,
+            pid: r.pid,
+            startedAt: r.startedAt,
+            dryRun: r.dryRun,
+            error: r.error,
+            source: 'other_process',
+          }));
+
+        return json({ available, running: [...inProcess, ...external] });
       },
     },
   ];