@swarmclawai/swarmclaw 0.7.1 → 0.7.3

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

@@ -0,0 +1,301 @@
+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 type { ToolBuildContext } from './context'
+
+interface ReplicateConfig {
+  apiToken: string
+  defaultModel: string
+  pollingIntervalMs: number
+  timeoutMs: number
+}
+
+function getConfig(): ReplicateConfig {
+  const ps = getPluginManager().getPluginSettings('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

@@ -6,6 +6,7 @@ import type { ToolBuildContext } from './context'
 import type { Plugin, PluginHooks } from '@/types'
 import { getPluginManager } from '../plugins'
 import { normalizeToolInputArgs } from './normalize-tool-args'
+import { createWatchJob } from '../watch-jobs'
 
 /**
  * Core Schedule Execution Logic
@@ -15,7 +16,7 @@ async function executeScheduleWake(args: { delayMinutes: number; message: string
   const delayMinutes = normalized.delayMinutes as number
   const message = normalized.message as string
   if (!context.sessionId) return 'Cannot schedule wake: no session context.'
-  if (delayMinutes < 0 || delayMinutes > 1440) return 'delayMinutes must be between 0 and 1440 (24 hours).'
+  if (delayMinutes < 0 || delayMinutes > 43_200) return 'delayMinutes must be between 0 and 43200 (30 days).'
 
   if (delayMinutes === 0) {
     enqueueSystemEvent(context.sessionId, `[Scheduled Wake Event / Reminder] ${message}`)
@@ -23,15 +24,24 @@ async function executeScheduleWake(args: { delayMinutes: number; message: string
     return 'Successfully scheduled an immediate wake event.'
   }
 
-  const delayMs = delayMinutes * 60 * 1000
-  setTimeout(() => {
-    if (context.sessionId) {
-      enqueueSystemEvent(context.sessionId, `[Scheduled Wake Event / Reminder] ${message}`)
-      requestHeartbeatNow({ sessionId: context.sessionId, reason: 'scheduled_wake' })
-    }
-  }, delayMs)
+  const runAt = Date.now() + delayMinutes * 60 * 1000
+  const watch = await createWatchJob({
+    type: 'time',
+    sessionId: context.sessionId,
+    resumeMessage: message,
+    description: `Scheduled wake in ${delayMinutes} minutes`,
+    target: { source: 'schedule_wake' },
+    condition: {},
+    runAt,
+  })
 
-  return `Successfully scheduled a wake event in ${delayMinutes} minutes.`
+  return JSON.stringify({
+    ok: true,
+    jobId: watch.id,
+    delayMinutes,
+    runAt,
+    message,
+  })
 }
 
 /**
@@ -39,8 +49,10 @@ 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,
+  description: 'Schedule durable wake events and reminders for agents.',
+  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 +76,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

@@ -33,6 +33,7 @@ async function executeSessionsAction(args: any, context: { sessionId?: string; a
   const limit = normalized.limit as number | undefined
   const agentId = (normalized.agentId ?? normalized.agent_id) as string | undefined
   const name = normalized.name as string | undefined
+  const updates = normalized.updates as Record<string, unknown> | undefined
   try {
     const sessions = loadSessions()
     if (action === 'list') {
@@ -51,14 +52,45 @@ 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 || [],
+        messages: [], createdAt: now, lastActiveAt: now, sessionType: 'human',
+        agentId: agent.id, parentSessionId: context.sessionId || undefined, plugins: agent.plugins || agent.tools || [],
       }
       saveSessions(sessions)
       return JSON.stringify({ sessionId: id, name: agent.name })
     }
+    if (action === 'update') {
+      const targetId = sessionId || context.sessionId || ''
+      if (!targetId) return 'sessionId required.'
+      const target = sessions[targetId]
+      if (!target) return 'Not found.'
+      const allowedKeys = new Set([
+        'thinkingLevel',
+        'connectorThinkLevel',
+        'sessionResetMode',
+        'sessionIdleTimeoutSec',
+        'sessionMaxAgeSec',
+        'sessionDailyResetAt',
+        'sessionResetTimezone',
+        'connectorSessionScope',
+        'connectorReplyMode',
+        'connectorThreadBinding',
+        'connectorGroupPolicy',
+        'connectorIdleTimeoutSec',
+        'connectorMaxAgeSec',
+        'identityState',
+        'provider',
+        'model',
+      ])
+      const patch = updates && typeof updates === 'object' ? updates : {}
+      for (const [key, value] of Object.entries(patch)) {
+        if (!allowedKeys.has(key)) continue
+        target[key] = value
+      }
+      saveSessions(sessions)
+      return JSON.stringify({ sessionId: targetId, updated: Object.keys(patch).filter((key) => allowedKeys.has(key)) })
+    }
     return `Unknown action "${action}".`
   } catch (err: any) { return `Error: ${err.message}` }
 }
@@ -69,7 +101,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',
@@ -83,11 +118,12 @@ const SessionInfoPlugin: Plugin = {
       parameters: {
         type: 'object',
         properties: {
-          action: { type: 'string', enum: ['list', 'history', 'spawn', 'status', 'stop'] },
+          action: { type: 'string', enum: ['list', 'history', 'spawn', 'status', 'stop', 'update'] },
           sessionId: { type: 'string' },
           agentId: { type: 'string' },
           message: { type: 'string' },
-          limit: { type: 'number' }
+          limit: { type: 'number' },
+          updates: { type: 'object' },
         },
         required: ['action']
       },
@@ -102,7 +138,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/session-tools-wiring.test.ts

@@ -24,6 +24,21 @@ describe('module exports', () => {
     const mem = await import('./memory')
     assert.equal(typeof mem.buildMemoryTools, 'function')
   })
+
+  it('primitive tool builders are exported', async () => {
+    const document = await import('./document')
+    const extract = await import('./extract')
+    const table = await import('./table')
+    const crawl = await import('./crawl')
+    const mailbox = await import('./mailbox')
+    const humanLoop = await import('./human-loop')
+    assert.equal(typeof document.buildDocumentTools, 'function')
+    assert.equal(typeof extract.buildExtractTools, 'function')
+    assert.equal(typeof table.buildTableTools, 'function')
+    assert.equal(typeof crawl.buildCrawlTools, 'function')
+    assert.equal(typeof mailbox.buildMailboxTools, 'function')
+    assert.equal(typeof humanLoop.buildHumanLoopTools, 'function')
+  })
 })
 
 // ---------------------------------------------------------------------------
@@ -60,46 +75,45 @@ describe('buildSessionTools signature', () => {
 })
 
 // ---------------------------------------------------------------------------
-// 4. Memory tool schema — knowledge actions
+// 4. Memory tool schema
 //    buildMemoryTools calls getMemoryDb() eagerly so we cannot invoke it
 //    without a real SQLite DB. Instead we read the source and verify the
-//    action enum includes the knowledge actions.
+//    declared action enum matches the current JSON schema definition.
 // ---------------------------------------------------------------------------
 describe('memory tool knowledge actions (source verification)', () => {
-  it('action enum in memory.ts includes knowledge_store and knowledge_search', async () => {
+  it('action enum in memory.ts includes the declared base actions', async () => {
     const fs = await import('fs')
     const src = fs.readFileSync(
       new URL('./memory.ts', import.meta.url).pathname,
       'utf-8',
     )
 
-    // Find the z.enum([...]) for the action field
-    const enumMatch = src.match(/z\.enum\(\[([^\]]+)\]\)\.describe\([^)]*action/s)
-    assert.ok(enumMatch, 'Should find a z.enum() for the action field')
+    const enumMatch = src.match(/action:\s*\{\s*type:\s*'string',\s*enum:\s*\[([^\]]+)\]/s)
+    assert.ok(enumMatch, 'Should find the action enum in the memory tool schema')
 
     const enumBody = enumMatch![1]
-    assert.ok(enumBody.includes("'knowledge_store'"), 'action enum should include knowledge_store')
-    assert.ok(enumBody.includes("'knowledge_search'"), 'action enum should include knowledge_search')
+    const expectedActions = ['store', 'get', 'search', 'list', 'delete']
+    for (const action of expectedActions) {
+      assert.ok(
+        enumBody.includes(`'${action}'`),
+        `action enum should include '${action}'`,
+      )
+    }
   })
 
-  it('action enum includes all expected base actions', async () => {
+  it('action enum does not advertise removed knowledge actions', async () => {
     const fs = await import('fs')
     const src = fs.readFileSync(
       new URL('./memory.ts', import.meta.url).pathname,
       'utf-8',
     )
 
-    const enumMatch = src.match(/z\.enum\(\[([^\]]+)\]\)/)
+    const enumMatch = src.match(/action:\s*\{\s*type:\s*'string',\s*enum:\s*\[([^\]]+)\]/s)
     assert.ok(enumMatch)
     const enumBody = enumMatch![1]
 
-    const expectedActions = ['store', 'get', 'search', 'list', 'delete', 'link', 'unlink', 'knowledge_store', 'knowledge_search']
-    for (const action of expectedActions) {
-      assert.ok(
-        enumBody.includes(`'${action}'`),
-        `action enum should include '${action}'`,
-      )
-    }
+    assert.equal(enumBody.includes("'knowledge_store'"), false)
+    assert.equal(enumBody.includes("'knowledge_search'"), false)
   })
 })
 

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 }),