@swarmclawai/swarmclaw 0.7.7 → 0.8.0

package/src/lib/server/plugins-advanced.test.ts

@@ -0,0 +1,351 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import {
+  canonicalizePluginId,
+  expandPluginIds,
+  getPluginAliases,
+  normalizePluginId,
+  pluginIdMatches,
+} from './tool-aliases'
+
+// ---------------------------------------------------------------------------
+// normalizePluginId
+// ---------------------------------------------------------------------------
+describe('normalizePluginId', () => {
+  it('converts uppercase to lowercase', () => {
+    assert.equal(normalizePluginId('WEB_SEARCH'), 'web_search')
+  })
+
+  it('trims leading and trailing whitespace', () => {
+    assert.equal(normalizePluginId('  shell  '), 'shell')
+  })
+
+  it('handles combined upper + whitespace', () => {
+    assert.equal(normalizePluginId('  WEB_SEARCH  '), 'web_search')
+  })
+
+  it('returns empty string for empty input', () => {
+    assert.equal(normalizePluginId(''), '')
+  })
+
+  it('returns already normalized value unchanged', () => {
+    assert.equal(normalizePluginId('files'), 'files')
+  })
+
+  it('returns empty string for non-string input (number)', () => {
+    assert.equal(normalizePluginId(42), '')
+  })
+
+  it('returns empty string for null', () => {
+    assert.equal(normalizePluginId(null), '')
+  })
+
+  it('returns empty string for undefined', () => {
+    assert.equal(normalizePluginId(undefined), '')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// canonicalizePluginId
+// ---------------------------------------------------------------------------
+describe('canonicalizePluginId', () => {
+  it('resolves web_search → web', () => {
+    assert.equal(canonicalizePluginId('web_search'), 'web')
+  })
+
+  it('resolves web_fetch → web', () => {
+    assert.equal(canonicalizePluginId('web_fetch'), 'web')
+  })
+
+  it('keeps web (already canonical)', () => {
+    assert.equal(canonicalizePluginId('web'), 'web')
+  })
+
+  it('resolves execute_command → shell', () => {
+    assert.equal(canonicalizePluginId('execute_command'), 'shell')
+  })
+
+  it('resolves memory_tool → memory', () => {
+    assert.equal(canonicalizePluginId('memory_tool'), 'memory')
+  })
+
+  it('keeps files (already canonical)', () => {
+    assert.equal(canonicalizePluginId('files'), 'files')
+  })
+
+  it('returns unknown plugin as-is', () => {
+    assert.equal(canonicalizePluginId('totally_unknown'), 'totally_unknown')
+  })
+
+  it('resolves delegate_to_claude_code → delegate', () => {
+    assert.equal(canonicalizePluginId('delegate_to_claude_code'), 'delegate')
+  })
+
+  it('resolves claude_code → delegate', () => {
+    assert.equal(canonicalizePluginId('claude_code'), 'delegate')
+  })
+
+  it('resolves process_tool → shell', () => {
+    assert.equal(canonicalizePluginId('process_tool'), 'shell')
+  })
+
+  it('resolves openclaw_browser → browser', () => {
+    assert.equal(canonicalizePluginId('openclaw_browser'), 'browser')
+  })
+
+  it('returns raw string (preserving case) for empty normalized result', () => {
+    // non-string input → normalizePluginId returns ''
+    assert.equal(canonicalizePluginId(123), '')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// expandPluginIds
+// ---------------------------------------------------------------------------
+describe('expandPluginIds', () => {
+  it('shell implies process', () => {
+    const result = expandPluginIds(['shell'])
+    assert.ok(result.includes('shell'))
+    assert.ok(result.includes('process'))
+  })
+
+  it('manage_platform expands to 10 sub-plugins', () => {
+    const result = expandPluginIds(['manage_platform'])
+    const expected = [
+      'manage_platform',
+      'manage_agents',
+      'manage_projects',
+      'manage_tasks',
+      'manage_schedules',
+      'manage_skills',
+      'manage_documents',
+      'manage_webhooks',
+      'manage_connectors',
+      'manage_sessions',
+      'manage_secrets',
+    ]
+    for (const e of expected) {
+      assert.ok(result.includes(e), `expected ${e} in expansion`)
+    }
+  })
+
+  it('web expands to include web_search and web_fetch', () => {
+    const result = expandPluginIds(['web'])
+    assert.ok(result.includes('web'))
+    assert.ok(result.includes('web_search'))
+    assert.ok(result.includes('web_fetch'))
+  })
+
+  it('removes duplicates after expansion', () => {
+    const result = expandPluginIds(['web', 'web_search', 'web_fetch'])
+    const unique = new Set(result)
+    assert.equal(result.length, unique.size)
+  })
+
+  it('returns empty array for empty input', () => {
+    assert.deepEqual(expandPluginIds([]), [])
+  })
+
+  it('keeps unknown plugin as-is', () => {
+    const result = expandPluginIds(['my_custom_plugin'])
+    assert.ok(result.includes('my_custom_plugin'))
+  })
+
+  it('deduplicates overlapping expansions from multiple inputs', () => {
+    const result = expandPluginIds(['web', 'web_search'])
+    const counts = result.reduce<Record<string, number>>((acc, id) => {
+      acc[id] = (acc[id] || 0) + 1
+      return acc
+    }, {})
+    for (const [id, count] of Object.entries(counts)) {
+      assert.equal(count, 1, `${id} appears ${count} times`)
+    }
+  })
+
+  it('returns empty array for null', () => {
+    assert.deepEqual(expandPluginIds(null), [])
+  })
+
+  it('returns empty array for undefined', () => {
+    assert.deepEqual(expandPluginIds(undefined), [])
+  })
+
+  it('shell also expands aliases (execute_command, process_tool)', () => {
+    const result = expandPluginIds(['shell'])
+    assert.ok(result.includes('execute_command'))
+    assert.ok(result.includes('process_tool'))
+  })
+
+  it('manage_platform + shell has no duplicates', () => {
+    const result = expandPluginIds(['manage_platform', 'shell'])
+    const unique = new Set(result)
+    assert.equal(result.length, unique.size)
+  })
+
+  it('handles same plugin requested multiple times', () => {
+    const result = expandPluginIds(['web', 'web', 'web'])
+    const webCount = result.filter((id) => id === 'web').length
+    assert.equal(webCount, 1)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// getPluginAliases
+// ---------------------------------------------------------------------------
+describe('getPluginAliases', () => {
+  it('web returns [web, web_search, web_fetch]', () => {
+    const result = getPluginAliases('web')
+    assert.ok(result.includes('web'))
+    assert.ok(result.includes('web_search'))
+    assert.ok(result.includes('web_fetch'))
+    assert.equal(result.length, 3)
+  })
+
+  it('web_search returns the same group as web', () => {
+    const fromWeb = getPluginAliases('web').sort()
+    const fromAlias = getPluginAliases('web_search').sort()
+    assert.deepEqual(fromWeb, fromAlias)
+  })
+
+  it('unknown plugin returns array with just the input', () => {
+    assert.deepEqual(getPluginAliases('unknown_thing'), ['unknown_thing'])
+  })
+
+  it('shell includes execute_command and process_tool', () => {
+    const result = getPluginAliases('shell')
+    assert.ok(result.includes('shell'))
+    assert.ok(result.includes('execute_command'))
+    assert.ok(result.includes('process_tool'))
+  })
+
+  it('returns empty array for empty string', () => {
+    assert.deepEqual(getPluginAliases(''), [])
+  })
+
+  it('returns empty array for null', () => {
+    assert.deepEqual(getPluginAliases(null), [])
+  })
+
+  it('delegate group includes all delegate variants', () => {
+    const result = getPluginAliases('delegate')
+    assert.ok(result.includes('claude_code'))
+    assert.ok(result.includes('delegate_to_claude_code'))
+    assert.ok(result.includes('codex_cli'))
+    assert.ok(result.includes('delegate_to_codex_cli'))
+  })
+})
+
+// ---------------------------------------------------------------------------
+// pluginIdMatches
+// ---------------------------------------------------------------------------
+describe('pluginIdMatches', () => {
+  it('web enabled, web_search matches (alias)', () => {
+    assert.equal(pluginIdMatches(['web'], 'web_search'), true)
+  })
+
+  it('web_search enabled, web matches (reverse alias)', () => {
+    assert.equal(pluginIdMatches(['web_search'], 'web'), true)
+  })
+
+  it('files enabled, shell does not match (different families)', () => {
+    assert.equal(pluginIdMatches(['files'], 'shell'), false)
+  })
+
+  it('manage_platform enabled, manage_tasks matches (implication)', () => {
+    assert.equal(pluginIdMatches(['manage_platform'], 'manage_tasks'), true)
+  })
+
+  it('empty enabled list, nothing matches', () => {
+    assert.equal(pluginIdMatches([], 'web'), false)
+  })
+
+  it('case insensitive match', () => {
+    assert.equal(pluginIdMatches(['WEB'], 'web_search'), true)
+  })
+
+  it('shell enabled, process matches (implication)', () => {
+    assert.equal(pluginIdMatches(['shell'], 'process'), true)
+  })
+
+  it('manage_platform enabled, manage_secrets matches', () => {
+    assert.equal(pluginIdMatches(['manage_platform'], 'manage_secrets'), true)
+  })
+
+  it('null enabled list returns false', () => {
+    assert.equal(pluginIdMatches(null, 'web'), false)
+  })
+
+  it('undefined enabled list returns false', () => {
+    assert.equal(pluginIdMatches(undefined, 'web'), false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Complex expansion scenarios
+// ---------------------------------------------------------------------------
+describe('complex expansion scenarios', () => {
+  it('shell + web + memory fully expands', () => {
+    const result = expandPluginIds(['shell', 'web', 'memory'])
+    // shell family
+    assert.ok(result.includes('shell'))
+    assert.ok(result.includes('execute_command'))
+    assert.ok(result.includes('process_tool'))
+    assert.ok(result.includes('process'))
+    // web family
+    assert.ok(result.includes('web'))
+    assert.ok(result.includes('web_search'))
+    assert.ok(result.includes('web_fetch'))
+    // memory family
+    assert.ok(result.includes('memory'))
+    assert.ok(result.includes('memory_tool'))
+  })
+
+  it('large plugin list (50+ items) all expanded correctly', () => {
+    const ids = Array.from({ length: 50 }, (_, i) => `custom_plugin_${i}`)
+    ids.push('shell', 'web')
+    const result = expandPluginIds(ids)
+    // All custom ones present
+    for (let i = 0; i < 50; i++) {
+      assert.ok(result.includes(`custom_plugin_${i}`))
+    }
+    // Shell expansion present
+    assert.ok(result.includes('process'))
+    // Web expansion present
+    assert.ok(result.includes('web_fetch'))
+  })
+
+  it('alias chains do not cause infinite loops', () => {
+    // delegate has many aliases; expansion should terminate
+    const result = expandPluginIds(['delegate'])
+    assert.ok(result.includes('delegate'))
+    assert.ok(result.includes('claude_code'))
+    assert.ok(result.includes('delegate_to_claude_code'))
+    // Just confirm it returned without hanging
+    assert.ok(result.length > 0)
+  })
+
+  it('connector aliases expand correctly', () => {
+    const result = expandPluginIds(['manage_connectors'])
+    assert.ok(result.includes('manage_connectors'))
+    assert.ok(result.includes('connectors'))
+    assert.ok(result.includes('connector_message_tool'))
+  })
+
+  it('sandbox aliases expand', () => {
+    const result = expandPluginIds(['sandbox'])
+    assert.ok(result.includes('sandbox'))
+    assert.ok(result.includes('sandbox_exec'))
+    assert.ok(result.includes('sandbox_list_runtimes'))
+  })
+
+  it('files expands to include read_file, write_file, etc.', () => {
+    const result = expandPluginIds(['files'])
+    assert.ok(result.includes('read_file'))
+    assert.ok(result.includes('write_file'))
+    assert.ok(result.includes('list_files'))
+    assert.ok(result.includes('copy_file'))
+    assert.ok(result.includes('move_file'))
+    assert.ok(result.includes('delete_file'))
+    assert.ok(result.includes('send_file'))
+  })
+})

package/src/lib/server/plugins.ts

@@ -4,6 +4,13 @@ import crypto from 'crypto'
 import { createRequire } from 'module'
 import { spawn } from 'child_process'
 import type { Plugin, PluginHooks, PluginMeta, PluginToolDef, PluginUIExtension, PluginProviderExtension, PluginConnectorExtension, Session, PluginPackageManager, PluginDependencyInstallStatus } from '@/types'
+import {
+  inferPluginInstallSourceFromUrl,
+  inferPluginPublisherSourceFromUrl,
+  isMarketplaceInstallSource,
+  normalizePluginInstallSource,
+  normalizePluginPublisherSource,
+} from '@/lib/plugin-sources'
 import { DATA_DIR } from './data-dir'
 import { canonicalizePluginId, expandPluginIds, getPluginAliases } from './tool-aliases'
 import { log } from './logger'
@@ -34,6 +41,9 @@ interface PluginFailureRecord {
 interface PluginConfigEntry {
   enabled?: boolean
   createdByAgentId?: string
+  source?: PluginMeta['source']
+  sourceLabel?: PluginMeta['sourceLabel']
+  installSource?: PluginMeta['installSource']
   sourceUrl?: string
   sourceHash?: string
   installedAt?: number
@@ -97,6 +107,8 @@ type HookRegistrar = {
 type HookContext<K extends keyof PluginHooks> =
   PluginHooks[K] extends ((ctx: infer C) => unknown) | undefined ? C : never
 
+type ApprovalGuidanceHook = NonNullable<PluginHooks['getApprovalGuidance']>
+
 /** Legacy OpenClaw format: activate(ctx)/deactivate() */
 interface OpenClawLegacyPlugin {
   name: string
@@ -105,13 +117,123 @@ interface OpenClawLegacyPlugin {
   deactivate?: () => void
 }
 
+function trimString(value: unknown): string {
+  return typeof value === 'string' ? value.trim() : ''
+}
+
+function normalizeApprovalGuidanceLines(
+  value: string | string[] | null | undefined,
+): string[] {
+  if (typeof value === 'string') {
+    const trimmed = value.trim()
+    return trimmed ? [trimmed] : []
+  }
+  if (!Array.isArray(value)) return []
+  return value
+    .map((line) => (typeof line === 'string' ? line.trim() : ''))
+    .filter(Boolean)
+}
+
+function dedupeApprovalGuidanceLines(lines: string[]): string[] {
+  return Array.from(new Set(lines.map((line) => line.trim()).filter(Boolean)))
+}
+
+function formatApprovalToolLabel(toolNames: string[]): string {
+  const uniqueNames = Array.from(new Set(toolNames.map((name) => name.trim()).filter(Boolean)))
+  if (uniqueNames.length === 0) return 'its tools'
+  if (uniqueNames.length === 1) return `\`${uniqueNames[0]}\``
+  if (uniqueNames.length === 2) return `\`${uniqueNames[0]}\` and \`${uniqueNames[1]}\``
+  return `${uniqueNames.slice(0, -1).map((name) => `\`${name}\``).join(', ')}, and \`${uniqueNames.at(-1)}\``
+}
+
+function buildDefaultPluginApprovalGuidance(params: {
+  pluginId: string
+  pluginName: string
+  tools: PluginToolDef[]
+}): ApprovalGuidanceHook {
+  const toolNames = params.tools
+    .map((tool) => (typeof tool?.name === 'string' ? tool.name.trim() : ''))
+    .filter(Boolean)
+  const toolLabel = formatApprovalToolLabel(toolNames)
+  const matchIds = new Set(
+    dedupeApprovalGuidanceLines([
+      params.pluginId,
+      ...toolNames,
+      ...expandPluginIds([params.pluginId]),
+      ...toolNames.flatMap((toolName) => expandPluginIds([toolName])),
+    ]).map((value) => canonicalizePluginId(value) || value.toLowerCase()),
+  )
+
+  return ({ approval, phase, approved }) => {
+    if (approval.category !== 'tool_access') return null
+    const requestedIds = [
+      trimString(approval.data.pluginId),
+      trimString(approval.data.toolId),
+      trimString(approval.data.toolName),
+    ].filter(Boolean)
+    const matchesPlugin = requestedIds.some((value) => {
+      const candidates = [value, ...expandPluginIds([value])]
+      return candidates.some((candidate) => matchIds.has(canonicalizePluginId(candidate) || candidate.toLowerCase()))
+    })
+    if (!matchesPlugin) return null
+
+    if (phase === 'connector_reminder') {
+      return `Approving this lets the agent use ${toolLabel} from ${params.pluginName}.`
+    }
+    if (approved === true) {
+      return [
+        `Access to ${params.pluginName} is approved. Continue with ${toolLabel} on the next turn.`,
+        'Do not request the same access again in prose once it has been approved.',
+      ]
+    }
+    if (approved === false) {
+      return `Do not request access to ${params.pluginName} again unless the task or required capability materially changes.`
+    }
+    return [
+      `If access to ${params.pluginName} is granted, continue with ${toolLabel} on the next turn.`,
+      'Do not ask for the same access again in prose while this approval is pending.',
+    ]
+  }
+}
+
+function composeApprovalGuidance(
+  defaultHook: ApprovalGuidanceHook,
+  customHook?: PluginHooks['getApprovalGuidance'],
+): ApprovalGuidanceHook {
+  return (ctx) => {
+    const combined = dedupeApprovalGuidanceLines([
+      ...normalizeApprovalGuidanceLines(defaultHook(ctx)),
+      ...normalizeApprovalGuidanceLines(customHook?.(ctx)),
+    ])
+    return combined.length > 0 ? combined : null
+  }
+}
+
+function buildPluginHooks(
+  pluginId: string,
+  pluginName: string,
+  hooks: PluginHooks | undefined,
+  tools: PluginToolDef[] | undefined,
+): PluginHooks {
+  const nextHooks: PluginHooks = { ...(hooks || {}) }
+  nextHooks.getApprovalGuidance = composeApprovalGuidance(
+    buildDefaultPluginApprovalGuidance({
+      pluginId,
+      pluginName,
+      tools: tools || [],
+    }),
+    hooks?.getApprovalGuidance,
+  )
+  return nextHooks
+}
+
 /**
  * Real OpenClaw plugin format: function export `(api) => {}` or object with `register(api)`.
  * Supports api.registerHook(), api.registerTool(), api.registerCommand(), api.registerService().
  */
 interface OpenClawPluginApi {
   registerHook: (event: string, handler: (...args: unknown[]) => unknown, meta?: { name?: string; description?: string }) => void
-  registerTool: (def: PluginToolDef | { name: string; description?: string; parameters?: Record<string, unknown>; execute: (...args: unknown[]) => unknown }) => void
+  registerTool: (def: PluginToolDef | { name: string; description?: string; parameters?: Record<string, unknown>; planning?: PluginToolDef['planning']; execute: (...args: unknown[]) => unknown }) => void
   registerCommand: (def: { name: string; description?: string; handler: (...args: unknown[]) => unknown }) => void
   registerService: (def: { id: string; start: () => void; stop?: () => void }) => void
   registerProvider: (def: Record<string, unknown>) => void
@@ -215,6 +337,30 @@ function toRawPluginUrl(url: string): string {
   return url
 }
 
+function inferStoredPluginSource(config: PluginConfigEntry | null | undefined): PluginMeta['source'] {
+  if (config?.source === 'local' || config?.source === 'manual' || config?.source === 'marketplace') {
+    return config.source
+  }
+  if (config?.sourceUrl) {
+    const installSource = normalizePluginInstallSource(config?.installSource)
+      || inferPluginInstallSourceFromUrl(config.sourceUrl)
+    return isMarketplaceInstallSource(installSource) ? 'marketplace' : 'manual'
+  }
+  return 'local'
+}
+
+function inferStoredPublisherSource(config: PluginConfigEntry | null | undefined): NonNullable<PluginMeta['sourceLabel']> {
+  return normalizePluginPublisherSource(config?.sourceLabel)
+    || inferPluginPublisherSourceFromUrl(config?.sourceUrl)
+    || (config?.sourceUrl ? 'manual' : 'local')
+}
+
+function inferStoredInstallSource(config: PluginConfigEntry | null | undefined): NonNullable<PluginMeta['installSource']> {
+  return normalizePluginInstallSource(config?.installSource)
+    || inferPluginInstallSourceFromUrl(config?.sourceUrl)
+    || (config?.sourceUrl ? 'manual' : 'local')
+}
+
 export function normalizeMarketplacePluginUrl(url: string): string {
   const trimmed = typeof url === 'string' ? url.trim() : ''
   if (!trimmed) return trimmed
@@ -295,6 +441,7 @@ function coerceTools(rawTools: unknown): PluginToolDef[] {
         name,
         description: typeof rawTool.description === 'string' ? rawTool.description : `Plugin tool: ${name}`,
         parameters: isRecord(rawTool.parameters) ? rawTool.parameters : { type: 'object', properties: {} },
+        planning: isRecord(rawTool.planning) ? rawTool.planning as PluginToolDef['planning'] : undefined,
         execute: execute as PluginToolDef['execute'],
       })
     }
@@ -320,6 +467,7 @@ function coerceTools(rawTools: unknown): PluginToolDef[] {
         name,
         description: typeof rawTool.description === 'string' ? rawTool.description : `Plugin tool: ${name}`,
         parameters: isRecord(rawTool.parameters) ? rawTool.parameters : { type: 'object', properties: {} },
+        planning: isRecord(rawTool.planning) ? rawTool.planning as PluginToolDef['planning'] : undefined,
         execute: rawTool.execute as PluginToolDef['execute'],
       })
     }
@@ -397,6 +545,9 @@ function normalizePlugin(mod: unknown): Plugin | null {
             name: def.name,
             description: def.description || `Plugin tool: ${def.name}`,
             parameters: (def.parameters || { type: 'object', properties: {} }) as Record<string, unknown>,
+            planning: isRecord((def as Record<string, unknown>).planning)
+              ? (def as PluginToolDef).planning
+              : undefined,
             execute: def.execute as PluginToolDef['execute'],
           })
         }
@@ -830,9 +981,11 @@ class PluginManager {
             author: p.author || 'SwarmClaw',
             version: p.version || '1.0.0',
             source: 'local',
+            sourceLabel: 'builtin',
+            installSource: 'builtin',
             openclaw: p.openclaw === true,
           },
-          hooks: p.hooks || {},
+          hooks: buildPluginHooks(id, p.name, p.hooks, p.tools),
           tools: p.tools || [],
           ui: p.ui,
           providers: p.providers,
@@ -850,7 +1003,7 @@ class PluginManager {
       
       let dynamicRequire: NodeRequire | null = null
       try {
-        dynamicRequire = createRequire(import.meta.url || __filename)
+        dynamicRequire = createRequire(path.join(process.cwd(), 'package.json'))
       } catch (err: unknown) {
         log.warn('plugins', 'createRequire failed; external plugins disabled', {
           error: err instanceof Error ? err.message : String(err),
@@ -881,10 +1034,13 @@ class PluginManager {
                 enabled: true,
                 author: plugin.author,
                 version: plugin.version || '0.0.1',
-                source: explicitConfig?.sourceUrl ? 'marketplace' : 'local',
+                source: inferStoredPluginSource(explicitConfig),
+                sourceLabel: inferStoredPublisherSource(explicitConfig),
+                installSource: inferStoredInstallSource(explicitConfig),
+                sourceUrl: explicitConfig?.sourceUrl,
                 openclaw: plugin.openclaw === true,
               },
-              hooks: plugin.hooks || {},
+              hooks: buildPluginHooks(file, plugin.name, plugin.hooks, plugin.tools),
               tools: plugin.tools || [],
               ui: plugin.ui,
               providers: plugin.providers,
@@ -1141,6 +1297,44 @@ class PluginManager {
     return lines
   }
 
+  /** Collect approval guidance from all enabled plugins for a specific approval event */
+  collectApprovalGuidance(
+    enabledPlugins: string[],
+    ctx: {
+      approval: import('@/types').ApprovalRequest
+      phase: 'request' | 'resume' | 'connector_reminder'
+      approved?: boolean
+    },
+  ): string[] {
+    this.load()
+    const enabledSet = new Set(expandPluginIds(enabledPlugins))
+    const lines: string[] = []
+
+    for (const [id, p] of this.plugins.entries()) {
+      if (!enabledSet.has(id)) continue
+      const hook = p.hooks.getApprovalGuidance
+      if (!hook) continue
+      try {
+        const result = hook(ctx)
+        if (result === null || result === undefined) continue
+        if (typeof result === 'string' && result.trim()) {
+          lines.push(result)
+        } else if (Array.isArray(result)) {
+          for (const line of result) {
+            if (typeof line === 'string' && line.trim()) lines.push(line)
+          }
+        }
+      } catch (err: unknown) {
+        log.error('plugins', 'getApprovalGuidance hook failed', {
+          pluginId: id,
+          error: err instanceof Error ? err.message : String(err),
+        })
+      }
+    }
+
+    return lines
+  }
+
   /** Collect all settings fields declared by enabled plugins */
   collectSettingsFields(enabledPlugins: string[]): Array<{ pluginId: string; pluginName: string; fields: import('@/types').PluginSettingsField[] }> {
     this.load()
@@ -1318,6 +1512,11 @@ class PluginManager {
     return true
   }
 
+  isExplicitlyDisabled(filename: string): boolean {
+    const explicit = this.readConfigEntry(filename)
+    return explicit?.enabled === false
+  }
+
   listPlugins(): PluginMeta[] {
     try {
       this.load()
@@ -1358,6 +1557,9 @@ class PluginManager {
           author: p.author || 'SwarmClaw',
           version: (p as { version?: string }).version || loaded?.meta.version || '1.0.0',
           source: loaded?.meta.source || 'local',
+          sourceLabel: 'builtin',
+          installSource: 'builtin',
+          sourceUrl: loaded?.meta.sourceUrl,
           openclaw: p.openclaw === true,
           failureCount: failure?.count,
           lastFailureAt: failure?.lastFailedAt,
@@ -1386,7 +1588,10 @@ class PluginManager {
               isBuiltin: false,
               author: loaded?.meta.author,
               version: loaded?.meta.version || '0.0.1',
-              source: loaded?.meta.source || (explicitCfg?.sourceUrl ? 'marketplace' : 'local'),
+              source: loaded?.meta.source || inferStoredPluginSource(explicitCfg),
+              sourceLabel: loaded?.meta.sourceLabel || inferStoredPublisherSource(explicitCfg),
+              installSource: loaded?.meta.installSource || inferStoredInstallSource(explicitCfg),
+              sourceUrl: loaded?.meta.sourceUrl || explicitCfg?.sourceUrl,
               openclaw: loaded?.meta.openclaw,
               createdByAgentId: explicitCfg?.createdByAgentId || null,
               failureCount: failure?.count,