@swarmclawai/swarmclaw 0.7.1 → 0.7.2

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

@@ -127,7 +127,144 @@ async function executeMemoryAction(input: any, ctx: any) {
 const MemoryPlugin: Plugin = {
   name: 'Core Memory',
   description: 'Advanced database-backed long-term memory with semantic search and graph linking.',
-  hooks: {} as PluginHooks,
+  hooks: {
+    getAgentContext: async (ctx) => {
+      const agentId = ctx.session.agentId
+      if (!agentId) return null
+
+      const memDb = getMemoryDb()
+      const memoryQuerySeed = [
+        ctx.message,
+        ...ctx.history
+          .slice(-4)
+          .filter((h) => h.role === 'user')
+          .map((h) => h.text),
+      ].join('\n')
+
+      const seen = new Set<string>()
+      const formatMemoryLine = (m: { category?: string; title?: string; content?: string; pinned?: boolean }) => {
+        const category = String(m.category || 'note')
+        const title = String(m.title || 'Untitled').replace(/\s+/g, ' ').trim()
+        const snippet = String(m.content || '').replace(/\s+/g, ' ').trim().slice(0, 220)
+        const pin = m.pinned ? ' [pinned]' : ''
+        return `- [${category}]${pin} ${title}: ${snippet}`
+      }
+
+      const pinned = memDb.listPinned(agentId, 5)
+      const pinnedLines = pinned
+        .filter((m) => { if (!m?.id || seen.has(m.id)) return false; seen.add(m.id); return true })
+        .map(formatMemoryLine)
+
+      const relevantSlice = Math.max(2, 6 - pinnedLines.length)
+      const relevantLookup = memDb.searchWithLinked(memoryQuerySeed, agentId, 1, 10, 14)
+      const relevant = relevantLookup.entries.slice(0, relevantSlice)
+      const recent = memDb.list(agentId, 12).slice(0, 6)
+
+      const relevantLines = relevant
+        .filter((m) => { if (!m?.id || seen.has(m.id)) return false; seen.add(m.id); return true })
+        .map(formatMemoryLine)
+
+      const recentLines = recent
+        .filter((m) => { if (!m?.id || seen.has(m.id)) return false; seen.add(m.id); return true })
+        .map(formatMemoryLine)
+
+      const parts: string[] = []
+      if (pinnedLines.length) {
+        parts.push(['## Pinned Memories', 'Always-loaded memories marked as important.', ...pinnedLines].join('\n'))
+      }
+      if (relevantLines.length) {
+        parts.push(['## Relevant Memory Hits', 'These memories were retrieved by relevance for the current objective.', ...relevantLines].join('\n'))
+      }
+      if (recentLines.length) {
+        parts.push(['## Recent Memory Notes', 'Recent durable notes that may still apply.', ...recentLines].join('\n'))
+      }
+
+      // Memory Policy
+      parts.push([
+        '## My Memory',
+        'I have long-term memory that persists across conversations. I use it naturally — I don\'t wait to be asked to remember things.',
+        '',
+        '**Things worth remembering:**',
+        '- What the user likes, dislikes, or has corrected me on',
+        '- Important decisions, outcomes, and lessons learned',
+        '- What I\'ve discovered about projects, codebases, or environments',
+        '- Problems I\'ve hit and how I solved them',
+        '- Who people are and how they relate to each other',
+        '- Configuration details and environment specifics that I\'ll need again',
+        '',
+        '**Not worth cluttering my memory with:**',
+        '- Throwaway acknowledgments or small talk',
+        '- Work-in-progress that\'ll change soon (use category "working" for scratch notes)',
+        '- Things already in my system prompt',
+        '- Something I\'ve already stored',
+        '',
+        '**Good habits:**',
+        '- Give memories clear titles ("User prefers dark mode" not "Note 1")',
+        '- Use categories: preference, fact, learning, project, identity, decision',
+        '- Check what I already know before storing something new',
+        '- When I learn something that corrects old knowledge, update or remove the old memory',
+      ].join('\n'))
+
+      // Pre-compaction consolidation nudge
+      const msgCount = ctx.history.filter(m => m.role === 'user' || m.role === 'assistant').length
+      if (msgCount > 20) {
+        parts.push([
+          '## Reflection & Consolidation Reminder',
+          'This conversation is getting long and I might lose older context soon.',
+          'Save anything important I\'ve learned, decided, or discovered to memory now. Only what matters, not every detail.',
+        ].join('\n'))
+      }
+
+      return parts.join('\n\n') || null
+    },
+    afterToolExec: (ctx) => {
+      const agentId = ctx.session.agentId
+      if (!agentId) return
+      const inp = ctx.input
+      if (!inp || typeof inp !== 'object') return
+      const action = typeof inp.action === 'string' ? inp.action : ''
+      let title: string | null = null
+      if (ctx.toolName === 'manage_tasks') {
+        if (action === 'create') title = `Created task: ${inp.title || 'Untitled'}`
+        else if (ctx.output && /status.*completed|completed.*successfully/i.test(ctx.output)) title = `Completed task: ${inp.title || inp.taskId || 'unknown'}`
+      }
+      if (ctx.toolName === 'manage_schedules' && action === 'create') title = `Created schedule: ${inp.name || 'Untitled'}`
+      if (ctx.toolName === 'manage_agents' && action === 'create') title = `Created agent: ${inp.name || 'Untitled'}`
+      if (!title) return
+      try {
+        const memDb = getMemoryDb()
+        memDb.add({ agentId, sessionId: ctx.session.id, category: 'breadcrumb', title, content: '' })
+      } catch { /* breadcrumbs are best-effort */ }
+    },
+    afterChatTurn: (ctx) => {
+      if (ctx.internal) return
+      if (ctx.source !== 'chat' && ctx.source !== 'connector') return
+      const agentId = ctx.session.agentId
+      if (!agentId) return
+      const msg = (ctx.message || '').trim()
+      const resp = (ctx.response || '').trim()
+      if (msg.length < 20 || resp.length < 40) return
+      if (/^(ok|okay|cool|thanks|thx|got it|nice)[.! ]*$/i.test(msg)) return
+      if (resp === 'HEARTBEAT_OK') return
+      const now = Date.now()
+      const last = typeof ctx.session.lastAutoMemoryAt === 'number' ? ctx.session.lastAutoMemoryAt : 0
+      if (last > 0 && now - last < 5 * 60 * 1000) return
+      try {
+        const memDb = getMemoryDb()
+        const compactMessage = msg.replace(/\s+/g, ' ').slice(0, 220)
+        const compactResponse = resp.replace(/\s+/g, ' ').slice(0, 700)
+        const autoTitle = `[auto] ${compactMessage.slice(0, 90)}`
+        const content = `source: ${ctx.source}\nuser_request: ${compactMessage}\nassistant_outcome: ${compactResponse}`
+        memDb.add({ agentId, sessionId: ctx.session.id, category: 'execution', title: autoTitle, content })
+        ctx.session.lastAutoMemoryAt = now
+      } catch { /* auto-memory is best-effort */ }
+    },
+    getCapabilityDescription: () => 'I have long-term memory (`memory_tool`) — I can remember things across conversations and recall them when needed.',
+    getOperatingGuidance: () => [
+      'Memory: search before major tasks, store concise notes after meaningful steps. Platform preloads context each turn.',
+      'For open goals, form a hypothesis and execute — do not keep re-asking broad questions.',
+    ],
+  } as PluginHooks,
   tools: [
     {
       name: 'memory_tool',
@@ -155,7 +292,7 @@ const MemoryPlugin: Plugin = {
 getPluginManager().registerBuiltin('memory', MemoryPlugin)
 
 export function buildMemoryTools(bctx: ToolBuildContext) {
-  if (!bctx.hasTool('memory')) return []
+  if (!bctx.hasPlugin('memory')) return []
   
   return [
     tool(

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

@@ -112,7 +112,7 @@ 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 }),

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.ts

@@ -16,7 +16,7 @@ async function executePlatformAction(args: any, bctx: any) {
   // 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',
@@ -45,7 +45,10 @@ 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',
@@ -71,7 +74,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(

package/src/lib/server/session-tools/plugin-creator.ts

@@ -70,9 +70,9 @@ async function executePluginCreatorAction(args: Record<string, unknown>, ctxOrBc
           const sessions = loadSessions()
           const session = sessions[pctx.sessionId!]
           if (session) {
-            const currentTools = session.tools || []
+            const currentTools = session.plugins || []
             if (!currentTools.includes(filename)) {
-              session.tools = [...currentTools, filename]
+              session.plugins = [...currentTools, filename]
               saveSessions(sessions)
             }
           }
@@ -220,7 +220,7 @@ getPluginManager().registerBuiltin('plugin_creator', PluginCreatorPlugin)
  * Legacy Bridge
  */
 export function buildPluginCreatorTools(bctx: ToolBuildContext): StructuredToolInterface[] {
-  if (!bctx.hasTool('plugin_creator')) return []
+  if (!bctx.hasPlugin('plugin_creator')) return []
   return [
     tool(
       async (args) => executePluginCreatorAction(args, bctx),

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

@@ -0,0 +1,303 @@
+import { z } from 'zod'
+import { tool, type StructuredToolInterface } from '@langchain/core/tools'
+import type { Plugin, PluginHooks } from '@/types'
+import { getPluginManager } from '../plugins'
+import { normalizeToolInputArgs } from './normalize-tool-args'
+import { loadSettings } from '../storage'
+import type { ToolBuildContext } from './context'
+
+interface ReplicateConfig {
+  apiToken: string
+  defaultModel: string
+  pollingIntervalMs: number
+  timeoutMs: number
+}
+
+function getConfig(): ReplicateConfig {
+  const settings = loadSettings()
+  const ps = (settings.pluginSettings as Record<string, Record<string, unknown>> | undefined)?.replicate ?? {}
+  return {
+    apiToken: (ps.apiToken as string) || '',
+    defaultModel: (ps.defaultModel as string) || '',
+    pollingIntervalMs: Number(ps.pollingIntervalMs) || 2000,
+    timeoutMs: Number(ps.timeoutMs) || 120000,
+  }
+}
+
+const API_BASE = 'https://api.replicate.com/v1'
+
+async function replicateRequest(
+  method: string,
+  path: string,
+  token: string,
+  body?: unknown,
+  extraHeaders?: Record<string, string>,
+): Promise<{ ok: boolean; data?: unknown; error?: string }> {
+  const headers: Record<string, string> = {
+    Authorization: `Bearer ${token}`,
+    'Content-Type': 'application/json',
+    ...extraHeaders,
+  }
+  const init: RequestInit = {
+    method,
+    headers,
+    signal: AbortSignal.timeout(15_000),
+  }
+  if (body && method !== 'GET' && method !== 'DELETE') {
+    init.body = JSON.stringify(body)
+  }
+  const res = await fetch(`${API_BASE}${path}`, init)
+  if (!res.ok) {
+    const errText = await res.text().catch(() => '')
+    return { ok: false, error: `Replicate ${res.status}: ${errText.slice(0, 400)}` }
+  }
+  const data = await res.json()
+  return { ok: true, data }
+}
+
+function formatPrediction(p: Record<string, unknown>): Record<string, unknown> {
+  return {
+    id: p.id,
+    model: p.model,
+    status: p.status,
+    output: p.output,
+    error: p.error,
+    logs: typeof p.logs === 'string' ? p.logs.slice(-500) : undefined,
+    metrics: p.metrics,
+    created_at: p.created_at,
+    started_at: p.started_at,
+    completed_at: p.completed_at,
+  }
+}
+
+async function pollPrediction(token: string, predictionId: string, cfg: ReplicateConfig): Promise<Record<string, unknown>> {
+  const deadline = Date.now() + cfg.timeoutMs
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, cfg.pollingIntervalMs))
+    const r = await replicateRequest('GET', `/predictions/${predictionId}`, token)
+    if (!r.ok) return { status: 'failed', error: r.error }
+    const prediction = r.data as Record<string, unknown>
+    if (prediction.status === 'succeeded' || prediction.status === 'failed' || prediction.status === 'canceled') {
+      return prediction
+    }
+  }
+  return { status: 'failed', error: 'Prediction timed out.' }
+}
+
+async function executeReplicate(args: Record<string, unknown>): Promise<string> {
+  const normalized = normalizeToolInputArgs(args)
+  const action = String(normalized.action || 'run')
+  const cfg = getConfig()
+
+  if (!cfg.apiToken) {
+    return 'Error: Replicate API token not configured. Ask the user to add it in Plugin Settings > Replicate.'
+  }
+
+  try {
+    switch (action) {
+      case 'run': {
+        const model = String(normalized.model || cfg.defaultModel || '').trim()
+        if (!model) return 'Error: "model" is required (e.g. "stability-ai/sdxl", "meta/llama-2-70b-chat").'
+
+        const input = (normalized.input as Record<string, unknown>) || {}
+        if (typeof normalized.prompt === 'string') {
+          input.prompt = normalized.prompt
+        }
+
+        const version = typeof normalized.version === 'string' ? normalized.version.trim() : undefined
+
+        // Build request body
+        const body: Record<string, unknown> = { input }
+        if (version) {
+          body.version = version
+        } else {
+          body.model = model
+        }
+
+        // Try sync mode first (Prefer: wait blocks up to 60s)
+        const r = await replicateRequest('POST', '/predictions', cfg.apiToken, body, { Prefer: 'wait' })
+        if (!r.ok) return `Error: ${r.error}`
+
+        let prediction = r.data as Record<string, unknown>
+
+        // If sync didn't complete, poll
+        if (prediction.status !== 'succeeded' && prediction.status !== 'failed' && prediction.status !== 'canceled') {
+          prediction = await pollPrediction(cfg.apiToken, String(prediction.id), cfg)
+        }
+
+        if (prediction.status === 'failed') {
+          return `Prediction failed: ${prediction.error || 'unknown error'}`
+        }
+
+        return JSON.stringify(formatPrediction(prediction))
+      }
+
+      case 'get': {
+        const predictionId = String(normalized.predictionId || normalized.id || '').trim()
+        if (!predictionId) return 'Error: "predictionId" is required.'
+
+        const r = await replicateRequest('GET', `/predictions/${predictionId}`, cfg.apiToken)
+        if (!r.ok) return `Error: ${r.error}`
+        return JSON.stringify(formatPrediction(r.data as Record<string, unknown>))
+      }
+
+      case 'cancel': {
+        const predictionId = String(normalized.predictionId || normalized.id || '').trim()
+        if (!predictionId) return 'Error: "predictionId" is required.'
+
+        const r = await replicateRequest('POST', `/predictions/${predictionId}/cancel`, cfg.apiToken)
+        if (!r.ok) return `Error: ${r.error}`
+        return `Prediction ${predictionId} canceled.`
+      }
+
+      case 'get_model': {
+        const model = String(normalized.model || '').trim()
+        if (!model) return 'Error: "model" is required (e.g. "stability-ai/sdxl").'
+
+        const r = await replicateRequest('GET', `/models/${model}`, cfg.apiToken)
+        if (!r.ok) return `Error: ${r.error}`
+        const data = r.data as Record<string, unknown>
+        return JSON.stringify({
+          owner: data.owner,
+          name: data.name,
+          description: data.description,
+          visibility: data.visibility,
+          url: data.url,
+          latest_version: data.latest_version ? {
+            id: (data.latest_version as Record<string, unknown>).id,
+            created_at: (data.latest_version as Record<string, unknown>).created_at,
+          } : null,
+          run_count: data.run_count,
+        })
+      }
+
+      case 'search': {
+        const query = String(normalized.query || normalized.search || '').trim()
+        const cursor = typeof normalized.cursor === 'string' ? normalized.cursor : undefined
+        const params = new URLSearchParams()
+        if (query) params.set('query', query)
+        if (cursor) params.set('cursor', cursor)
+        const suffix = params.toString() ? `?${params}` : ''
+        const r = await replicateRequest('GET', `/models${suffix}`, cfg.apiToken)
+        if (!r.ok) return `Error: ${r.error}`
+        const data = r.data as Record<string, unknown>
+        const results = (data.results as Record<string, unknown>[]) ?? []
+        const items = results.slice(0, 20).map((m) => ({
+          owner: m.owner,
+          name: m.name,
+          description: typeof m.description === 'string' ? m.description.slice(0, 120) : '',
+          run_count: m.run_count,
+          url: m.url,
+        }))
+        return JSON.stringify({
+          models: items,
+          next_cursor: data.next ? (data.next as string).split('cursor=')[1]?.split('&')[0] : null,
+        })
+      }
+
+      case 'status': {
+        return JSON.stringify({
+          configured: true,
+          hasToken: !!cfg.apiToken,
+          defaultModel: cfg.defaultModel || '(none)',
+          timeoutMs: cfg.timeoutMs,
+        })
+      }
+
+      default:
+        return `Error: Unknown action "${action}". Use: run, get, cancel, get_model, search, status.`
+    }
+  } catch (err: unknown) {
+    return `Error: ${err instanceof Error ? err.message : String(err)}`
+  }
+}
+
+const ReplicatePlugin: Plugin = {
+  name: 'Replicate',
+  enabledByDefault: false,
+  description: 'Run any AI model on Replicate — image generation, LLMs, audio, video, and more. Search models, create predictions, check status.',
+  hooks: {
+    getCapabilityDescription: () =>
+      'I can run any AI model on Replicate using `replicate`. This includes image generation (SDXL, Flux), language models, audio/video processing, and thousands more. I can search for models, run predictions, and check their status.',
+  } as PluginHooks,
+  tools: [
+    {
+      name: 'replicate',
+      description: 'Run AI models on Replicate. Actions: run (create and wait for prediction), get (check prediction status), cancel (stop a prediction), get_model (model details), search (find models), status (check config).',
+      parameters: {
+        type: 'object',
+        properties: {
+          action: { type: 'string', enum: ['run', 'get', 'cancel', 'get_model', 'search', 'status'], description: 'Action to perform' },
+          model: { type: 'string', description: 'Model identifier (e.g. "stability-ai/sdxl", "meta/llama-2-70b-chat"). Required for run/get_model.' },
+          version: { type: 'string', description: 'Optional specific model version hash for run.' },
+          input: { type: 'object', description: 'Model input parameters as key-value pairs (for run). Varies by model.' },
+          prompt: { type: 'string', description: 'Shorthand: sets input.prompt for models that accept a prompt (for run).' },
+          predictionId: { type: 'string', description: 'Prediction ID (for get/cancel).' },
+          query: { type: 'string', description: 'Search query (for search).' },
+          cursor: { type: 'string', description: 'Pagination cursor (for search).' },
+        },
+        required: ['action'],
+      },
+      execute: async (args) => executeReplicate(args),
+    },
+  ],
+  ui: {
+    settingsFields: [
+      {
+        key: 'apiToken',
+        label: 'API Token',
+        type: 'secret',
+        required: true,
+        placeholder: 'r8_...',
+        help: 'Your Replicate API token. Find it at replicate.com/account/api-tokens.',
+      },
+      {
+        key: 'defaultModel',
+        label: 'Default Model',
+        type: 'text',
+        placeholder: 'stability-ai/sdxl',
+        help: 'Default model to use when none is specified. Format: owner/model-name.',
+      },
+      {
+        key: 'timeoutMs',
+        label: 'Timeout (ms)',
+        type: 'number',
+        defaultValue: 120000,
+        help: 'Maximum time to wait for a prediction (default: 120000ms / 2 minutes).',
+      },
+      {
+        key: 'pollingIntervalMs',
+        label: 'Polling Interval (ms)',
+        type: 'number',
+        defaultValue: 2000,
+        help: 'How often to poll for prediction results when sync mode times out (default: 2000ms).',
+      },
+    ],
+  },
+}
+
+getPluginManager().registerBuiltin('replicate', ReplicatePlugin)
+
+export function buildReplicateTools(bctx: ToolBuildContext): StructuredToolInterface[] {
+  if (!bctx.hasPlugin('replicate')) return []
+
+  return [
+    tool(
+      async (args) => executeReplicate(args),
+      {
+        name: 'replicate',
+        description: ReplicatePlugin.tools![0].description,
+        schema: z.object({
+          action: z.enum(['run', 'get', 'cancel', 'get_model', 'search', 'status']).describe('Action to perform'),
+          model: z.string().optional().describe('Model identifier (e.g. "stability-ai/sdxl")'),
+          version: z.string().optional().describe('Specific model version hash'),
+          input: z.record(z.string(), z.unknown()).optional().describe('Model input parameters'),
+          prompt: z.string().optional().describe('Shorthand for input.prompt'),
+          predictionId: z.string().optional().describe('Prediction ID (for get/cancel)'),
+          query: z.string().optional().describe('Search query (for search)'),
+          cursor: z.string().optional().describe('Pagination cursor (for search)'),
+        }),
+      },
+    ),
+  ]
+}

package/src/lib/server/session-tools/sample-ui.ts

@@ -80,7 +80,7 @@ const SampleUIPlugin: Plugin = {
 getPluginManager().registerBuiltin('sample_ui', SampleUIPlugin)
 
 export function buildSampleUITools(bctx: any) {
-  if (!bctx.hasTool('sample_ui')) return []
+  if (!bctx.hasPlugin('sample_ui')) return []
   return [
     tool(
       async (args) => SampleUIPlugin.tools![0].execute(args as any, bctx),

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

@@ -143,7 +143,9 @@ async function executeListRuntimes() {
 const SandboxPlugin: Plugin = {
   name: 'Core Sandbox',
   description: 'Secure isolated code execution for JS, TS, and Python.',
-  hooks: {} as PluginHooks,
+  hooks: {
+    getCapabilityDescription: () => 'I can run code in a sandbox (`sandbox_exec`) — JS/TS via Deno or Python, in an isolated environment. I get stdout, stderr, and any files created.',
+  } as PluginHooks,
   tools: [
     {
       name: 'sandbox_exec',
@@ -174,7 +176,7 @@ getPluginManager().registerBuiltin('sandbox', SandboxPlugin)
  * Legacy Bridge
  */
 export function buildSandboxTools(bctx: ToolBuildContext): StructuredToolInterface[] {
-  if (!bctx.hasTool('sandbox')) return []
+  if (!bctx.hasPlugin('sandbox')) return []
   const tools: StructuredToolInterface[] = []
 
   tools.push(

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

@@ -40,7 +40,9 @@ async function executeScheduleWake(args: { delayMinutes: number; message: string
 const SchedulePlugin: Plugin = {
   name: 'Core Scheduler',
   description: 'Schedule wake events and reminders for agents.',
-  hooks: {} as PluginHooks,
+  hooks: {
+    getCapabilityDescription: () => 'I can set a conversational timer (`schedule_wake`) to remind myself to check back on something later in this chat.',
+  } as PluginHooks,
   tools: [
     {
       name: 'schedule_wake',
@@ -64,7 +66,7 @@ getPluginManager().registerBuiltin('schedule', SchedulePlugin)
  * Legacy Bridge
  */
 export function buildScheduleTools(bctx: ToolBuildContext): StructuredToolInterface[] {
-  if (!bctx.hasTool('schedule_wake')) return []
+  if (!bctx.hasPlugin('schedule_wake')) return []
   return [
     tool(
       async (args) => executeScheduleWake(args as any, { sessionId: bctx.ctx?.sessionId || undefined }),

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

@@ -51,10 +51,10 @@ async function executeSessionsAction(args: any, context: { sessionId?: string; a
       const id = genId()
       const now = Date.now()
       sessions[id] = {
-        id, name: (name || `${agent.name} Session`).trim(), cwd: context.cwd, user: 'system',
+        id, name: (name || `${agent.name} Chat`).trim(), cwd: context.cwd, user: 'system',
         provider: agent.provider, model: agent.model, credentialId: agent.credentialId || null,
         messages: [], createdAt: now, lastActiveAt: now, sessionType: 'orchestrated',
-        agentId: agent.id, parentSessionId: context.sessionId || undefined, tools: agent.tools || [],
+        agentId: agent.id, parentSessionId: context.sessionId || undefined, plugins: agent.plugins || agent.tools || [],
       }
       saveSessions(sessions)
       return JSON.stringify({ sessionId: id, name: agent.name })
@@ -69,7 +69,10 @@ async function executeSessionsAction(args: any, context: { sessionId?: string; a
 const SessionInfoPlugin: Plugin = {
   name: 'Core Session Info',
   description: 'Identify current session context and manage other agent sessions.',
-  hooks: {} as PluginHooks,
+  hooks: {
+    getCapabilityDescription: () => 'I can manage chat sessions (`manage_sessions`, `sessions_tool`, `whoami_tool`, `search_history_tool`) — check my identity, look up past conversations, message other sessions, and coordinate work.',
+    getOperatingGuidance: () => 'Inspect existing chats before creating duplicates.',
+  } as PluginHooks,
   tools: [
     {
       name: 'whoami_tool',
@@ -102,7 +105,7 @@ getPluginManager().registerBuiltin('session_info', SessionInfoPlugin)
  * Legacy Bridge
  */
 export function buildSessionInfoTools(bctx: ToolBuildContext): StructuredToolInterface[] {
-  if (!bctx.hasTool('manage_sessions')) return []
+  if (!bctx.hasPlugin('manage_sessions')) return []
   return [
     tool(
       async () => executeWhoAmI({ sessionId: bctx.ctx?.sessionId || undefined, agentId: bctx.ctx?.agentId || undefined }),

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

@@ -162,7 +162,10 @@ async function executeShellAction(args: Record<string, unknown>, bctx: { cwd: st
 const ShellPlugin: Plugin = {
   name: 'Core Shell',
   description: 'Execute shell commands and manage background processes.',
-  hooks: {} as PluginHooks,
+  hooks: {
+    getCapabilityDescription: () => 'I can run shell commands (`execute_command`) — servers, installs, scripts, git, builds, anything. I can run things in the background for long-lived processes like dev servers.',
+    getOperatingGuidance: () => ['Shell: use `execute_command` for servers, installs, scripts, git. Use `background=true` for long-lived processes.', 'Verify servers with `process_tool` status/log and liveness probes before claiming success.', 'Resolve IPs/URLs via shell — never use placeholders. Retry path errors without workdir override.'],
+  } as PluginHooks,
   tools: [
     {
       name: 'shell',
@@ -185,7 +188,7 @@ const ShellPlugin: Plugin = {
 getPluginManager().registerBuiltin('shell', ShellPlugin)
 
 export function buildShellTools(bctx: ToolBuildContext) {
-  if (!bctx.hasTool('shell')) return []
+  if (!bctx.hasPlugin('shell')) return []
   return [
     tool(
       async (args) => executeShellAction(args, { ...bctx.ctx, cwd: bctx.cwd }),

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

@@ -52,7 +52,7 @@ async function executeSubagentAction(args: any, context: { sessionId?: string; c
       id: sid, name: `subagent-${agent.name}`, cwd: cwd || context.cwd, user: 'agent',
       provider: agent.provider, model: agent.model, credentialId: agent.credentialId || null,
       messages: [], createdAt: now, lastActiveAt: now, sessionType: 'orchestrated',
-      agentId: agent.id, parentSessionId: context.sessionId || null, tools: agent.tools || [],
+      agentId: agent.id, parentSessionId: context.sessionId || null, plugins: agent.plugins || agent.tools || [],
     }
     saveSessions(sessions)
 
@@ -92,7 +92,7 @@ getPluginManager().registerBuiltin('subagent', SubagentPlugin)
  * Legacy Bridge
  */
 export function buildSubagentTools(bctx: ToolBuildContext): StructuredToolInterface[] {
-  if (!bctx.hasTool('spawn_subagent')) return []
+  if (!bctx.hasPlugin('spawn_subagent')) return []
   return [
     tool(
       async (args) => executeSubagentAction(args, { sessionId: bctx.ctx?.sessionId || undefined, cwd: bctx.cwd }),