@swarmclawai/swarmclaw 0.7.1 → 0.7.3

package/src/lib/server/session-tools/monitor.ts

@@ -8,16 +8,98 @@ import { getPluginManager } from '../plugins'
 import type { Plugin, PluginHooks } from '@/types'
 import { safePath, truncate } from './context'
 import { normalizeToolInputArgs } from './normalize-tool-args'
+import { cancelWatchJob, createWatchJob, getWatchJob, listWatchJobs } from '../watch-jobs'
+import { ensureSessionBrowserProfileId, loadBrowserSessionRecord } from '../browser-state'
+
+type WatchKind = 'time' | 'http' | 'file' | 'task' | 'webhook' | 'page'
+
+async function createDurableWatch(
+  normalized: Record<string, unknown>,
+  bctx: { cwd: string; sessionId?: string; agentId?: string | null },
+  explicitType?: WatchKind,
+) {
+  const watchType = (explicitType || String(normalized.watchType || normalized.type || '').trim().toLowerCase()) as WatchKind
+  if (!watchType) return 'Error: watchType is required.'
+  if (!['time', 'http', 'file', 'task', 'webhook', 'page'].includes(watchType)) {
+    return `Error: Unsupported watchType "${watchType}".`
+  }
+
+  const sessionId = typeof normalized.sessionId === 'string' ? normalized.sessionId : bctx.sessionId
+  const agentId = typeof normalized.agentId === 'string' ? normalized.agentId : (bctx.agentId || undefined)
+  const resumeMessage = String(normalized.resumeMessage || normalized.message || '').trim()
+  if (!resumeMessage) return 'Error: resumeMessage is required.'
+
+  const target = (normalized.target ?? normalized.url ?? normalized.path) as string | undefined
+  const delayMinutes = typeof normalized.delayMinutes === 'number' ? normalized.delayMinutes : undefined
+  const runAt = typeof normalized.runAt === 'number'
+    ? normalized.runAt
+    : delayMinutes !== undefined
+      ? Date.now() + Math.max(0, delayMinutes) * 60_000
+      : undefined
+  const intervalMs = typeof normalized.intervalSec === 'number'
+    ? Math.max(15, normalized.intervalSec) * 1000
+    : typeof normalized.intervalMs === 'number'
+      ? Math.max(15_000, normalized.intervalMs)
+      : undefined
+  const timeoutAt = typeof normalized.timeoutMinutes === 'number'
+    ? Date.now() + Math.max(1, normalized.timeoutMinutes) * 60_000
+    : typeof normalized.timeoutAt === 'number'
+      ? normalized.timeoutAt
+      : undefined
+  const browserProfileId = sessionId ? ensureSessionBrowserProfileId(sessionId).profileId : null
+  const targetPath = watchType === 'file' && target ? safePath(bctx.cwd, target) : target
+  const pageUrl = watchType === 'page' && !target && sessionId
+    ? loadBrowserSessionRecord(sessionId)?.currentUrl || undefined
+    : undefined
+  const pageTarget = target || pageUrl
+  if ((watchType === 'http' || watchType === 'page') && !pageTarget) {
+    return `Error: ${watchType === 'page' ? 'url or active browser page' : 'url'} is required.`
+  }
+
+  const job = await createWatchJob({
+    type: watchType,
+    sessionId: sessionId || null,
+    agentId: agentId || null,
+    createdByAgentId: agentId || null,
+    browserProfileId,
+    description: typeof normalized.description === 'string' ? normalized.description : null,
+    resumeMessage,
+    runAt,
+    intervalMs,
+    timeoutAt,
+    target: {
+      url: watchType === 'http' || watchType === 'page' ? pageTarget : undefined,
+      path: watchType === 'file' ? targetPath : undefined,
+      taskId: watchType === 'task' ? String(normalized.taskId || normalized.id || '') : undefined,
+      webhookId: watchType === 'webhook' ? String(normalized.webhookId || normalized.id || '') : undefined,
+      baselineHash: undefined,
+    },
+    condition: {
+      containsText: typeof normalized.containsText === 'string' ? normalized.containsText : undefined,
+      textGone: typeof normalized.textGone === 'string' ? normalized.textGone : undefined,
+      regex: typeof normalized.regex === 'string' ? normalized.regex : undefined,
+      changed: normalized.changed === true,
+      exists: normalized.exists,
+      status: typeof normalized.status === 'number' ? normalized.status : undefined,
+      statusIn: Array.isArray(normalized.statusIn) ? normalized.statusIn : undefined,
+      event: typeof normalized.event === 'string' ? normalized.event : undefined,
+      threshold: typeof normalized.threshold === 'number' ? normalized.threshold : undefined,
+    },
+  })
+  return JSON.stringify(job, null, 2)
+}
 
 /**
  * Unified Monitoring Logic
  */
-async function executeMonitorAction(args: any, bctx: { cwd: string }) {
+async function executeMonitorAction(args: any, bctx: { cwd: string; sessionId?: string; agentId?: string | null }) {
   const normalized = normalizeToolInputArgs((args ?? {}) as Record<string, unknown>)
   const action = normalized.action as string | undefined
   const target = (normalized.target ?? normalized.url ?? normalized.path) as string | undefined
   const limit = normalized.limit as number | undefined
   const threshold = normalized.threshold as number | undefined
+  const sessionId = typeof normalized.sessionId === 'string' ? normalized.sessionId : bctx.sessionId
+  const agentId = typeof normalized.agentId === 'string' ? normalized.agentId : (bctx.agentId || undefined)
 
   try {
     switch (action) {
@@ -65,6 +147,7 @@ async function executeMonitorAction(args: any, bctx: { cwd: string }) {
             status: res.status,
             ok: res.ok,
             latency: `${latency}ms`,
+            thresholdExceeded: typeof threshold === 'number' ? latency >= threshold : undefined,
             url
           }, null, 2)
         } catch (err: any) {
@@ -76,6 +159,55 @@ async function executeMonitorAction(args: any, bctx: { cwd: string }) {
         }
       }
 
+      case 'create_watch': {
+        return createDurableWatch(normalized, bctx)
+      }
+
+      case 'wait_until': {
+        return createDurableWatch(normalized, bctx, 'time')
+      }
+
+      case 'wait_for_http': {
+        return createDurableWatch(normalized, bctx, 'http')
+      }
+
+      case 'wait_for_file': {
+        return createDurableWatch(normalized, bctx, 'file')
+      }
+
+      case 'wait_for_task': {
+        return createDurableWatch(normalized, bctx, 'task')
+      }
+
+      case 'wait_for_webhook': {
+        return createDurableWatch(normalized, bctx, 'webhook')
+      }
+
+      case 'wait_for_page_change': {
+        return createDurableWatch(normalized, bctx, 'page')
+      }
+
+      case 'list_watches': {
+        const filterSessionId = normalized.all === true ? undefined : sessionId
+        return JSON.stringify(listWatchJobs({ sessionId: filterSessionId || null }), null, 2)
+      }
+
+      case 'get_watch': {
+        const id = String(normalized.id || '').trim()
+        if (!id) return 'Error: id is required.'
+        const job = getWatchJob(id)
+        if (!job) return `Error: watch job "${id}" not found.`
+        return JSON.stringify(job, null, 2)
+      }
+
+      case 'cancel_watch': {
+        const id = String(normalized.id || '').trim()
+        if (!id) return 'Error: id is required.'
+        const job = cancelWatchJob(id)
+        if (!job) return `Error: watch job "${id}" not found.`
+        return JSON.stringify(job, null, 2)
+      }
+
       default:
         return `Error: Unknown action "${action}"`
     }
@@ -89,22 +221,29 @@ async function executeMonitorAction(args: any, bctx: { cwd: string }) {
  */
 const MonitorPlugin: Plugin = {
   name: 'Core Monitor',
-  description: 'System observability: check resource usage, watch logs, and ping endpoints.',
+  description: 'System observability and durable watch jobs: inspect system state, monitor files/endpoints/tasks, and resume agents when conditions trigger.',
   hooks: {} as PluginHooks,
   tools: [
     {
       name: 'monitor_tool',
-      description: 'Observe system health, log activity, or endpoint availability.',
+      description: 'Observe system health, inspect logs/endpoints, or create durable waits like wait_for_http, wait_for_file, wait_for_webhook, and wait_for_page_change.',
       parameters: {
         type: 'object',
         properties: {
-          action: { type: 'string', enum: ['sys_info', 'watch_log', 'ping'] },
+          action: { type: 'string', enum: ['sys_info', 'watch_log', 'ping', 'create_watch', 'wait_until', 'wait_for_http', 'wait_for_file', 'wait_for_task', 'wait_for_webhook', 'wait_for_page_change', 'list_watches', 'get_watch', 'cancel_watch'] },
           target: { type: 'string', description: 'Log file path (for watch_log) or URL (for ping)' },
-          limit: { type: 'number', description: 'Number of lines or bytes to retrieve' }
+          limit: { type: 'number', description: 'Number of lines or bytes to retrieve' },
+          watchType: { type: 'string', enum: ['time', 'http', 'file', 'task', 'webhook', 'page'] },
+          resumeMessage: { type: 'string', description: 'Message injected when the watch triggers and the agent wakes up.' },
+          regex: { type: 'string', description: 'Regex pattern used by file/page/http watchers.' },
         },
         required: ['action']
       },
-      execute: async (args, context) => executeMonitorAction(args, { cwd: context.session.cwd || process.cwd() })
+      execute: async (args, context) => executeMonitorAction(args, {
+        cwd: context.session.cwd || process.cwd(),
+        sessionId: context.session.id,
+        agentId: context.session.agentId,
+      })
     }
   ]
 }
@@ -112,10 +251,14 @@ const MonitorPlugin: Plugin = {
 getPluginManager().registerBuiltin('monitor', MonitorPlugin)
 
 export function buildMonitorTools(bctx: ToolBuildContext): StructuredToolInterface[] {
-  if (!bctx.hasTool('monitor')) return []
+  if (!bctx.hasPlugin('monitor')) return []
   return [
     tool(
-      async (args) => executeMonitorAction(args, { cwd: bctx.cwd }),
+      async (args) => executeMonitorAction(args, {
+        cwd: bctx.cwd,
+        sessionId: bctx.ctx?.sessionId || undefined,
+        agentId: bctx.ctx?.agentId || undefined,
+      }),
       {
         name: 'monitor_tool',
         description: MonitorPlugin.tools![0].description,

package/src/lib/server/session-tools/normalize-tool-args.ts

@@ -1,4 +1,5 @@
 export type ToolArgsRecord = Record<string, unknown>
+const NESTED_WRAPPER_KEYS = ['input', 'args', 'arguments', 'payload', 'parameters'] as const
 
 function parseRecordCandidate(value: unknown): ToolArgsRecord | null {
   if (!value) return null
@@ -26,22 +27,24 @@ function parseRecordCandidate(value: unknown): ToolArgsRecord | null {
  * as either objects or JSON strings.
  */
 export function normalizeToolInputArgs(rawArgs: ToolArgsRecord): ToolArgsRecord {
-  const nestedSources: Array<ToolArgsRecord | null> = [
-    parseRecordCandidate(rawArgs.input),
-    parseRecordCandidate(rawArgs.args),
-    parseRecordCandidate(rawArgs.arguments),
-    parseRecordCandidate(rawArgs.payload),
-  ]
-
   const normalized: ToolArgsRecord = {}
-  for (const nested of nestedSources) {
-    if (!nested) continue
-    Object.assign(normalized, nested)
-  }
+  const queue: ToolArgsRecord[] = [rawArgs]
+  const visited = new Set<ToolArgsRecord>()
+
+  while (queue.length > 0) {
+    const current = queue.shift()
+    if (!current || visited.has(current)) continue
+    visited.add(current)
 
-  for (const [key, value] of Object.entries(rawArgs)) {
-    if (value === undefined || value === null) continue
-    normalized[key] = value
+    for (const key of NESTED_WRAPPER_KEYS) {
+      const nested = parseRecordCandidate(current[key])
+      if (nested) queue.push(nested)
+    }
+
+    for (const [key, value] of Object.entries(current)) {
+      if (value === undefined || value === null) continue
+      normalized[key] = value
+    }
   }
 
   return normalized

package/src/lib/server/session-tools/openclaw-nodes.ts

@@ -81,7 +81,7 @@ getPluginManager().registerBuiltin('openclaw_nodes', NodesPlugin)
  * Legacy Bridge
  */
 export function buildOpenClawNodeTools(bctx: ToolBuildContext): StructuredToolInterface[] {
-  if (!bctx.hasTool('openclaw_nodes')) return []
+  if (!bctx.hasPlugin('openclaw_nodes')) return []
   return [
     tool(
       async (args) => executeNodesAction(args),

package/src/lib/server/session-tools/openclaw-workspace.ts

@@ -128,7 +128,7 @@ getPluginManager().registerBuiltin('openclaw_workspace', WorkspacePlugin)
  * Legacy Bridge
  */
 export function buildOpenClawWorkspaceTools(bctx: ToolBuildContext): StructuredToolInterface[] {
-  if (!bctx.hasTool('openclaw_workspace')) return []
+  if (!bctx.hasPlugin('openclaw_workspace')) return []
   return [
     tool(
       async (args) => executeWorkspaceAction(args),

package/src/lib/server/session-tools/platform-normalize.test.ts

@@ -0,0 +1,142 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import { normalizePlatformActionArgs } from './platform'
+
+describe('normalizePlatformActionArgs', () => {
+  it('packs top-level create fields into data', () => {
+    const out = normalizePlatformActionArgs({
+      resource: 'tasks',
+      action: 'create',
+      title: 'Write docs',
+      agentId: 'default',
+    })
+
+    assert.equal(out.resource, 'tasks')
+    assert.equal(out.action, 'create')
+    assert.deepEqual(JSON.parse(String(out.data)), {
+      title: 'Write docs',
+      agentId: 'default',
+    })
+  })
+
+  it('merges object data with top-level overrides', () => {
+    const out = normalizePlatformActionArgs({
+      resource: 'tasks',
+      action: 'create',
+      data: { title: 'Old title', agentId: 'coder' },
+      title: 'New title',
+    })
+
+    assert.deepEqual(JSON.parse(String(out.data)), {
+      title: 'New title',
+      agentId: 'coder',
+    })
+  })
+
+  it('normalizes legacy resources envelope with parameters payload', () => {
+    const out = normalizePlatformActionArgs({
+      input: JSON.stringify({
+        resources: [
+          {
+            resource: 'tasks',
+            action: 'create',
+            parameters: {
+              title: 'Legacy task',
+              assigned_agent: 'default',
+            },
+          },
+        ],
+      }),
+    })
+
+    assert.equal(out.resource, 'tasks')
+    assert.equal(out.action, 'create')
+    assert.deepEqual(JSON.parse(String(out.data)), {
+      title: 'Legacy task',
+      assigned_agent: 'default',
+    })
+  })
+
+  it('normalizes singular resource names and resource payload objects', () => {
+    const out = normalizePlatformActionArgs({
+      input: JSON.stringify({
+        resource: 'task',
+        action: 'create',
+        task: {
+          title: 'Legacy singular task',
+          assigned_to: 'default',
+        },
+      }),
+    })
+
+    assert.equal(out.resource, 'tasks')
+    assert.equal(out.action, 'create')
+    assert.deepEqual(JSON.parse(String(out.data)), {
+      title: 'Legacy singular task',
+      assigned_to: 'default',
+    })
+  })
+
+  it('normalizes legacy backlog task resource names to tasks', () => {
+    const out = normalizePlatformActionArgs({
+      input: JSON.stringify({
+        resource: 'backlog_task',
+        action: 'create',
+        backlog_task: {
+          title: 'Legacy backlog task',
+          description: 'Keep the intended task payload',
+        },
+      }),
+    })
+
+    assert.equal(out.resource, 'tasks')
+    assert.equal(out.action, 'create')
+    assert.deepEqual(JSON.parse(String(out.data)), {
+      title: 'Legacy backlog task',
+      description: 'Keep the intended task payload',
+    })
+  })
+
+  it('normalizes resources entries that use type instead of resource', () => {
+    const out = normalizePlatformActionArgs({
+      input: JSON.stringify({
+        action: 'create',
+        resources: [
+          {
+            type: 'task',
+            parameters: {
+              title: 'Typed task resource',
+              description: 'Created through a typed resources envelope',
+            },
+          },
+        ],
+      }),
+    })
+
+    assert.equal(out.resource, 'tasks')
+    assert.equal(out.action, 'create')
+    assert.deepEqual(JSON.parse(String(out.data)), {
+      title: 'Typed task resource',
+      description: 'Created through a typed resources envelope',
+    })
+  })
+
+  it('infers schedules resource from create_schedule style actions', () => {
+    const out = normalizePlatformActionArgs({
+      input: JSON.stringify({
+        action: 'create_schedule',
+        data: {
+          name: 'Surgery check-in',
+          scheduleType: 'once',
+        },
+      }),
+    })
+
+    assert.equal(out.resource, 'schedules')
+    assert.equal(out.action, 'create')
+    assert.deepEqual(JSON.parse(String(out.data)), {
+      name: 'Surgery check-in',
+      scheduleType: 'once',
+    })
+  })
+})

package/src/lib/server/session-tools/platform.ts

@@ -6,17 +6,155 @@ import type { Plugin, PluginHooks } from '@/types'
 import { getPluginManager } from '../plugins'
 import { normalizeToolInputArgs } from './normalize-tool-args'
 
+function parsePlatformData(value: unknown): Record<string, unknown> | null {
+  if (!value) return null
+  if (typeof value === 'object' && !Array.isArray(value)) {
+    return value as Record<string, unknown>
+  }
+  if (typeof value !== 'string') return null
+  const trimmed = value.trim()
+  if (!trimmed) return null
+  try {
+    const parsed = JSON.parse(trimmed)
+    if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+      return parsed as Record<string, unknown>
+    }
+  } catch {
+    // Preserve non-JSON data strings as-is in the caller.
+  }
+  return null
+}
+
+function firstPlatformResource(value: unknown): Record<string, unknown> | null {
+  if (!Array.isArray(value)) return null
+  const first = value.find((entry) => entry && typeof entry === 'object' && !Array.isArray(entry))
+  return first && typeof first === 'object' && !Array.isArray(first)
+    ? first as Record<string, unknown>
+    : null
+}
+
+function normalizePlatformResourceName(value: unknown): string | undefined {
+  if (typeof value !== 'string') return undefined
+  const normalized = value.trim().toLowerCase()
+  if (!normalized) return undefined
+  const singularMap: Record<string, string> = {
+    agent: 'agents',
+    task: 'tasks',
+    backlog_task: 'tasks',
+    'backlog-task': 'tasks',
+    backlogtask: 'tasks',
+    task_backlog: 'tasks',
+    'task-backlog': 'tasks',
+    work_item: 'tasks',
+    'work-item': 'tasks',
+    schedule: 'schedules',
+    skill: 'skills',
+    document: 'documents',
+    secret: 'secrets',
+    connector: 'connectors',
+    session: 'sessions',
+  }
+  return singularMap[normalized] || normalized
+}
+
+function inferPlatformResourceFromAction(value: unknown): { resource?: string; action?: string } {
+  if (typeof value !== 'string') return {}
+  const normalized = value.trim().toLowerCase().replace(/-/g, '_')
+  if (!normalized) return {}
+  const match = normalized.match(/^(list|get|create|update|delete)_([a-z_]+)$/)
+  if (!match) return {}
+  const [, action, rawResource] = match
+  const resource = normalizePlatformResourceName(rawResource)
+  if (!resource) return {}
+  return { resource, action }
+}
+
+function extractPlatformFields(value: Record<string, unknown>): Record<string, unknown> {
+  const fields: Record<string, unknown> = {}
+  for (const [key, fieldValue] of Object.entries(value)) {
+    if (fieldValue === undefined || fieldValue === null) continue
+    if (['input', 'args', 'arguments', 'payload', 'resources', 'parameters', 'resource', 'type', 'action', 'id'].includes(key)) continue
+    fields[key] = fieldValue
+  }
+  return fields
+}
+
+export function normalizePlatformActionArgs(rawArgs: Record<string, unknown>): Record<string, unknown> {
+  const normalized = normalizeToolInputArgs(rawArgs)
+  const resourceEntry = firstPlatformResource(normalized.resources)
+  const { resource, action, id, data, ...rest } = normalized
+  const payload: Record<string, unknown> = {}
+  const resourceValue = resource ?? resourceEntry?.resource ?? resourceEntry?.type
+  const rawResourceName = typeof resourceValue === 'string'
+    ? String(resourceValue).trim()
+    : undefined
+
+  const rawAction = action ?? resourceEntry?.action
+  const inferredFromAction = resourceValue === undefined
+    ? inferPlatformResourceFromAction(rawAction)
+    : {}
+  const effectiveResource = normalizePlatformResourceName(resourceValue) ?? inferredFromAction.resource
+  const effectiveAction = inferredFromAction.action && resourceValue === undefined
+    ? inferredFromAction.action
+    : rawAction
+  const effectiveId = id ?? resourceEntry?.id
+
+  if (effectiveResource !== undefined) payload.resource = effectiveResource
+  if (effectiveAction !== undefined) payload.action = effectiveAction
+  if (effectiveId !== undefined) payload.id = effectiveId
+
+  const directFields = extractPlatformFields(rest)
+  const resourcePayloadCandidates = effectiveResource
+    ? uniqueStrings([
+        rawResourceName,
+        effectiveResource,
+        effectiveResource.replace(/s$/, ''),
+      ])
+    : []
+  const directResourcePayload = resourcePayloadCandidates
+    .map((candidate) => parsePlatformData(normalized[candidate]))
+    .find(Boolean)
+    || null
+  if (effectiveResource) {
+    for (const candidate of resourcePayloadCandidates) delete directFields[candidate]
+  }
+  const parameterFields = {
+    ...(parsePlatformData(resourceEntry?.parameters) || {}),
+    ...(parsePlatformData(resourceEntry?.params) || {}),
+    ...(parsePlatformData(normalized.parameters) || {}),
+    ...(directResourcePayload || {}),
+  }
+  const parsedData = parsePlatformData(data)
+  const mergedData = {
+    ...(parsedData || {}),
+    ...parameterFields,
+    ...directFields,
+  }
+
+  if (Object.keys(mergedData).length > 0) {
+    payload.data = JSON.stringify(mergedData)
+  } else if (typeof data === 'string' && data.trim()) {
+    payload.data = data
+  }
+
+  return payload
+}
+
+function uniqueStrings(values: Array<string | undefined>): string[] {
+  return [...new Set(values.filter((value): value is string => Boolean(value)))]
+}
+
 /**
  * Unified Platform Execution Logic
  */
 async function executePlatformAction(args: any, bctx: any) {
-  const normalized = normalizeToolInputArgs((args ?? {}) as Record<string, unknown>)
-  const { resource, action, id, data, ...rest } = normalized
+  const normalized = normalizePlatformActionArgs((args ?? {}) as Record<string, unknown>)
+  const { resource, action, id, data } = normalized
   
   // We reuse the existing CRUD tool logic but expose it via a single tool
   const crudTools = buildCrudTools({
     ...bctx,
-    hasTool: (id: string) => [
+    hasPlugin: (id: string) => [
       'manage_agents',
       'manage_tasks',
       'manage_schedules',
@@ -36,7 +174,7 @@ async function executePlatformAction(args: any, bctx: any) {
   }
 
   // Forward to the specific CRUD tool implementation
-  return targetTool.invoke({ action, id, data, ...rest })
+  return targetTool.invoke({ action, id, data })
 }
 
 /**
@@ -45,11 +183,14 @@ async function executePlatformAction(args: any, bctx: any) {
 const PlatformPlugin: Plugin = {
   name: 'Core Platform',
   description: 'Unified management of agents, tasks, schedules, skills, documents, and secrets.',
-  hooks: {} as PluginHooks,
+  hooks: {
+    getCapabilityDescription: () => 'I can create and configure other agents (`manage_agents`), manage tasks (`manage_tasks`), set up schedules (`manage_schedules`), store and search documents (`manage_documents`), register webhooks (`manage_webhooks`), manage reusable skills (`manage_skills`), and store encrypted secrets (`manage_secrets`).',
+    getOperatingGuidance: () => ['Create/update tasks for long-lived goals to track progress.', 'Use schedules for follow-ups. Check existing schedules before creating new ones.', 'Inspect existing chats before creating duplicates.'],
+  } as PluginHooks,
   tools: [
     {
       name: 'manage_platform',
-      description: 'Unified tool for managing all SwarmClaw resources.',
+      description: 'Unified tool for managing all SwarmClaw resources. For create/update, pass resource + action, then either put fields inside data, pass them as top-level fields, or use a single resources[0].parameters envelope.',
       parameters: {
         type: 'object',
         properties: {
@@ -71,7 +212,7 @@ getPluginManager().registerBuiltin('manage_platform', PlatformPlugin)
  * Legacy Bridge
  */
 export function buildPlatformTools(bctx: ToolBuildContext): StructuredToolInterface[] {
-  if (!bctx.hasTool('manage_platform')) return []
+  if (!bctx.hasPlugin('manage_platform')) return []
 
   return [
     tool(