@swarmclawai/swarmclaw 0.7.1 → 0.7.2

package/src/lib/server/queue.ts

@@ -4,14 +4,14 @@ import path from 'node:path'
 import { loadTasks, saveTasks, loadQueue, saveQueue, loadAgents, loadSchedules, saveSchedules, loadSessions, saveSessions, loadSettings, loadConnectors, UPLOAD_DIR } from './storage'
 import { notify } from './ws-hub'
 import { WORKSPACE_DIR } from './data-dir'
-import { createOrchestratorSession, executeOrchestrator } from './orchestrator'
+import { createOrchestratorSession } from './orchestrator'
 import { formatValidationFailure, validateTaskCompletion } from './task-validation'
 import { ensureTaskCompletionReport } from './task-reports'
 import { pushMainLoopEventToMainSessions } from './main-agent-loop'
 import { executeSessionChatTurn } from './chat-execution'
 import { extractTaskResult, formatResultBody } from './task-result'
 import { getCheckpointSaver } from './langgraph-checkpoint'
-import { isProtectedMainSession } from './main-session'
+import { isMainLoopSession } from './main-session'
 import { cascadeUnblock } from './dag-validation'
 import { performGuardianRollback } from './guardian'
 import type { Agent, BoardTask, Connector, Message } from '@/types'
@@ -283,7 +283,7 @@ function pushQueueUnique(queue: string[], id: string): void {
 }
 
 function isMainSession(session: SessionLike | null | undefined): boolean {
-  return isProtectedMainSession(session)
+  return isMainLoopSession(session)
 }
 
 function resolveTaskOwnerUser(task: ScheduleTaskMeta, sessions: Record<string, SessionLike>): string | null {
@@ -521,10 +521,8 @@ async function executeTaskRun(
     '- Include concrete evidence in your final summary: changed file paths, commands run, and verification results.',
     '- If blocked, state the blocker explicitly and what input or permission is missing.',
   ].join('\n')
-  if (agent?.isOrchestrator) {
-    return executeOrchestrator(agent, prompt, sessionId, task.id)
-  }
-
+  // All agents (including orchestrators) go through the unified chat execution path.
+  // Agents with subAgentIds get delegation tools automatically via session-tools.
   const run = await executeSessionChatTurn({
     sessionId,
     message: prompt,
@@ -773,6 +771,7 @@ function notifyAgentThreadTaskResult(task: BoardTask): void {
   if (task.claudeResumeId) resumeLines.push(`Claude session: \`${task.claudeResumeId}\``)
   if (task.codexResumeId) resumeLines.push(`Codex thread: \`${task.codexResumeId}\``)
   if (task.opencodeResumeId) resumeLines.push(`OpenCode session: \`${task.opencodeResumeId}\``)
+  if (task.geminiResumeId) resumeLines.push(`Gemini session: \`${task.geminiResumeId}\``)
   // Fallback to legacy field
   if (resumeLines.length === 0 && task.cliResumeId) {
     resumeLines.push(`${task.cliProvider || 'CLI'} session: \`${task.cliResumeId}\``)
@@ -1315,24 +1314,27 @@ export async function processNext() {
             const execSession = execSessions[sessionId] as Record<string, unknown> | undefined
             if (execSession) {
               const delegateIds = execSession.delegateResumeIds as
-                | { claudeCode?: string | null; codex?: string | null; opencode?: string | null }
+                | { claudeCode?: string | null; codex?: string | null; opencode?: string | null; gemini?: string | null }
                 | undefined
               // Store each CLI resume ID separately
               const claudeId = (execSession.claudeSessionId as string) || delegateIds?.claudeCode || null
               const codexId = (execSession.codexThreadId as string) || delegateIds?.codex || null
               const opencodeId = (execSession.opencodeSessionId as string) || delegateIds?.opencode || null
+              const geminiId = delegateIds?.gemini || null
               if (claudeId) t2[taskId].claudeResumeId = claudeId
               if (codexId) t2[taskId].codexResumeId = codexId
               if (opencodeId) t2[taskId].opencodeResumeId = opencodeId
+              if (geminiId) t2[taskId].geminiResumeId = geminiId
               // Keep backward-compat single field (first available)
-              const primaryId = claudeId || codexId || opencodeId
+              const primaryId = claudeId || codexId || opencodeId || geminiId
               if (primaryId) {
                 t2[taskId].cliResumeId = primaryId
                 if (claudeId) t2[taskId].cliProvider = 'claude-cli'
                 else if (codexId) t2[taskId].cliProvider = 'codex-cli'
                 else if (opencodeId) t2[taskId].cliProvider = 'opencode-cli'
+                else if (geminiId) t2[taskId].cliProvider = 'gemini-cli'
               }
-              console.log(`[queue] CLI resume IDs for task ${taskId}: claude=${claudeId}, codex=${codexId}, opencode=${opencodeId}`)
+              console.log(`[queue] CLI resume IDs for task ${taskId}: claude=${claudeId}, codex=${codexId}, opencode=${opencodeId}, gemini=${geminiId}`)
             }
           } catch (e) {
             console.warn(`[queue] Failed to extract CLI resume IDs for task ${taskId}:`, e)

package/src/lib/server/session-run-manager.test.ts

@@ -3,14 +3,10 @@ import assert from 'node:assert/strict'
 import { isMainMissionSession } from './session-run-manager'
 
 describe('isMainMissionSession', () => {
-  it('accepts explicit main sessions', () => {
-    assert.equal(isMainMissionSession({ id: 'main-user', name: '__main__' }), true)
-  })
-
-  it('rejects human agent-thread sessions', () => {
+  it('accepts agent-thread sessions', () => {
     assert.equal(
       isMainMissionSession({ id: 'agent-thread-agent_coder-123', name: 'agent-thread:agent_coder', sessionType: 'human' }),
-      false,
+      true,
     )
   })
 
@@ -20,4 +16,11 @@ describe('isMainMissionSession', () => {
       true,
     )
   })
+
+  it('rejects regular chat sessions', () => {
+    assert.equal(
+      isMainMissionSession({ id: 'abc123', name: 'New Chat', sessionType: 'human' }),
+      false,
+    )
+  })
 })

package/src/lib/server/session-run-manager.ts

@@ -220,10 +220,8 @@ function scheduleMainLoopFollowup(sessionId: string, followup: MainLoopFollowupR
 
 export function isMainMissionSession(session: Record<string, unknown>): boolean {
   const id = typeof session.id === 'string' ? session.id.trim() : ''
-  const name = typeof session.name === 'string' ? session.name.trim() : ''
   const sessionType = typeof session.sessionType === 'string' ? session.sessionType : ''
-  if (id.startsWith('main-') || name === '__main__') return true
-  // Only orchestrated thread sessions should receive autonomous main-loop followups.
+  if (id.startsWith('agent-thread-')) return true
   if (sessionType === 'orchestrated') return true
   return false
 }

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

@@ -0,0 +1,376 @@
+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'
+
+type CalendarProvider = 'google' | 'outlook'
+
+interface CalendarConfig {
+  provider: CalendarProvider
+  accessToken: string
+  calendarId: string
+  refreshToken: string
+  clientId: string
+  clientSecret: string
+}
+
+function getConfig(): CalendarConfig {
+  const settings = loadSettings()
+  const ps = (settings.pluginSettings as Record<string, Record<string, unknown>> | undefined)?.calendar ?? {}
+  return {
+    provider: (ps.provider as CalendarProvider) || 'google',
+    accessToken: (ps.accessToken as string) || '',
+    calendarId: (ps.calendarId as string) || 'primary',
+    refreshToken: (ps.refreshToken as string) || '',
+    clientId: (ps.clientId as string) || '',
+    clientSecret: (ps.clientSecret as string) || '',
+  }
+}
+
+/** Try to refresh the Google OAuth access token using the refresh token. */
+async function refreshGoogleToken(cfg: CalendarConfig): Promise<string | null> {
+  if (!cfg.refreshToken || !cfg.clientId || !cfg.clientSecret) return null
+  try {
+    const res = await fetch('https://oauth2.googleapis.com/token', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+      body: new URLSearchParams({
+        grant_type: 'refresh_token',
+        refresh_token: cfg.refreshToken,
+        client_id: cfg.clientId,
+        client_secret: cfg.clientSecret,
+      }),
+      signal: AbortSignal.timeout(10_000),
+    })
+    if (!res.ok) return null
+    const data = await res.json()
+    const newToken = data?.access_token as string | undefined
+    if (newToken) {
+      // Persist the refreshed token
+      const settings = loadSettings()
+      const pluginSettings = (settings.pluginSettings as Record<string, Record<string, unknown>> | undefined) ?? {}
+      const calSettings = pluginSettings.calendar ?? {}
+      calSettings.accessToken = newToken
+      pluginSettings.calendar = calSettings
+      settings.pluginSettings = pluginSettings
+      const { saveSettings } = await import('../storage')
+      saveSettings(settings)
+    }
+    return newToken || null
+  } catch {
+    return null
+  }
+}
+
+async function googleRequest(method: string, urlPath: string, cfg: CalendarConfig, body?: unknown): Promise<{ ok: boolean; data?: unknown; error?: string }> {
+  let token = cfg.accessToken
+  const baseUrl = 'https://www.googleapis.com/calendar/v3'
+
+  const doFetch = async (t: string) => {
+    const init: RequestInit = {
+      method,
+      headers: { Authorization: `Bearer ${t}`, 'Content-Type': 'application/json' },
+      signal: AbortSignal.timeout(15_000),
+    }
+    if (body && method !== 'GET' && method !== 'DELETE') init.body = JSON.stringify(body)
+    return fetch(`${baseUrl}${urlPath}`, init)
+  }
+
+  let res = await doFetch(token)
+  if (res.status === 401) {
+    const refreshed = await refreshGoogleToken(cfg)
+    if (refreshed) {
+      token = refreshed
+      res = await doFetch(token)
+    }
+  }
+
+  if (!res.ok) {
+    const errText = await res.text().catch(() => '')
+    return { ok: false, error: `Google Calendar ${res.status}: ${errText.slice(0, 300)}` }
+  }
+  if (method === 'DELETE') return { ok: true }
+  const data = await res.json()
+  return { ok: true, data }
+}
+
+async function outlookRequest(method: string, urlPath: string, cfg: CalendarConfig, body?: unknown): Promise<{ ok: boolean; data?: unknown; error?: string }> {
+  const baseUrl = 'https://graph.microsoft.com/v1.0/me'
+  const init: RequestInit = {
+    method,
+    headers: { Authorization: `Bearer ${cfg.accessToken}`, 'Content-Type': 'application/json' },
+    signal: AbortSignal.timeout(15_000),
+  }
+  if (body && method !== 'GET' && method !== 'DELETE') init.body = JSON.stringify(body)
+  const res = await fetch(`${baseUrl}${urlPath}`, init)
+  if (!res.ok) {
+    const errText = await res.text().catch(() => '')
+    return { ok: false, error: `Outlook ${res.status}: ${errText.slice(0, 300)}` }
+  }
+  if (method === 'DELETE') return { ok: true }
+  const data = await res.json()
+  return { ok: true, data }
+}
+
+function formatEvent(e: Record<string, unknown>): Record<string, unknown> {
+  return {
+    id: e.id,
+    summary: e.summary ?? e.subject,
+    start: (e.start as Record<string, unknown>)?.dateTime ?? (e.start as Record<string, unknown>)?.date ?? e.start,
+    end: (e.end as Record<string, unknown>)?.dateTime ?? (e.end as Record<string, unknown>)?.date ?? e.end,
+    location: e.location ?? (e.location as unknown as Record<string, unknown>)?.displayName,
+    description: typeof e.description === 'string' ? e.description.slice(0, 200) : (e.body as Record<string, unknown>)?.content?.toString().slice(0, 200),
+    status: e.status ?? e.showAs,
+    htmlLink: e.htmlLink ?? e.webLink,
+  }
+}
+
+async function executeCalendar(args: Record<string, unknown>): Promise<string> {
+  const normalized = normalizeToolInputArgs(args)
+  const action = String(normalized.action || 'list')
+  const cfg = getConfig()
+
+  if (!cfg.accessToken) {
+    return 'Error: Calendar not configured. Ask the user to add their access token in Plugin Settings > Calendar.'
+  }
+
+  try {
+    switch (action) {
+      case 'list': {
+        const timeMin = String(normalized.timeMin || new Date().toISOString())
+        const timeMax = normalized.timeMax as string | undefined
+        const maxResults = Math.min(Number(normalized.maxResults) || 20, 50)
+
+        if (cfg.provider === 'outlook') {
+          const params = new URLSearchParams({
+            $top: String(maxResults),
+            $orderby: 'start/dateTime',
+            $filter: `start/dateTime ge '${timeMin}'${timeMax ? ` and end/dateTime le '${timeMax}'` : ''}`,
+          })
+          const r = await outlookRequest('GET', `/calendar/events?${params}`, cfg)
+          if (!r.ok) return `Error: ${r.error}`
+          const events = ((r.data as Record<string, unknown>)?.value as Record<string, unknown>[]) ?? []
+          return JSON.stringify(events.map(formatEvent))
+        }
+
+        const params = new URLSearchParams({
+          timeMin,
+          maxResults: String(maxResults),
+          singleEvents: 'true',
+          orderBy: 'startTime',
+        })
+        if (timeMax) params.set('timeMax', timeMax)
+        const r = await googleRequest('GET', `/calendars/${encodeURIComponent(cfg.calendarId)}/events?${params}`, cfg)
+        if (!r.ok) return `Error: ${r.error}`
+        const events = ((r.data as Record<string, unknown>)?.items as Record<string, unknown>[]) ?? []
+        return JSON.stringify(events.map(formatEvent))
+      }
+
+      case 'create': {
+        const summary = String(normalized.summary || normalized.title || '').trim()
+        if (!summary) return 'Error: "summary" (event title) is required.'
+        const start = String(normalized.start || '').trim()
+        const end = String(normalized.end || '').trim()
+        if (!start) return 'Error: "start" (ISO datetime) is required.'
+
+        const description = (normalized.description as string) || ''
+        const location = (normalized.location as string) || ''
+
+        if (cfg.provider === 'outlook') {
+          const body = {
+            subject: summary,
+            body: { contentType: 'text', content: description },
+            start: { dateTime: start, timeZone: 'UTC' },
+            end: { dateTime: end || new Date(new Date(start).getTime() + 3600_000).toISOString(), timeZone: 'UTC' },
+            location: { displayName: location },
+          }
+          const r = await outlookRequest('POST', '/calendar/events', cfg, body)
+          if (!r.ok) return `Error: ${r.error}`
+          return `Event created: ${JSON.stringify(formatEvent(r.data as Record<string, unknown>))}`
+        }
+
+        const body = {
+          summary,
+          description,
+          location,
+          start: { dateTime: start, timeZone: 'UTC' },
+          end: { dateTime: end || new Date(new Date(start).getTime() + 3600_000).toISOString(), timeZone: 'UTC' },
+        }
+        const r = await googleRequest('POST', `/calendars/${encodeURIComponent(cfg.calendarId)}/events`, cfg, body)
+        if (!r.ok) return `Error: ${r.error}`
+        return `Event created: ${JSON.stringify(formatEvent(r.data as Record<string, unknown>))}`
+      }
+
+      case 'update': {
+        const eventId = String(normalized.eventId || normalized.id || '').trim()
+        if (!eventId) return 'Error: "eventId" is required.'
+        const updates: Record<string, unknown> = {}
+        if (normalized.summary) updates.summary = String(normalized.summary)
+        if (normalized.description) updates.description = String(normalized.description)
+        if (normalized.location) updates.location = String(normalized.location)
+        if (normalized.start) updates.start = { dateTime: String(normalized.start), timeZone: 'UTC' }
+        if (normalized.end) updates.end = { dateTime: String(normalized.end), timeZone: 'UTC' }
+
+        if (cfg.provider === 'outlook') {
+          const outlookUpdates: Record<string, unknown> = {}
+          if (normalized.summary) outlookUpdates.subject = String(normalized.summary)
+          if (normalized.description) outlookUpdates.body = { contentType: 'text', content: String(normalized.description) }
+          if (normalized.location) outlookUpdates.location = { displayName: String(normalized.location) }
+          if (normalized.start) outlookUpdates.start = { dateTime: String(normalized.start), timeZone: 'UTC' }
+          if (normalized.end) outlookUpdates.end = { dateTime: String(normalized.end), timeZone: 'UTC' }
+          const r = await outlookRequest('PATCH', `/calendar/events/${eventId}`, cfg, outlookUpdates)
+          if (!r.ok) return `Error: ${r.error}`
+          return `Event updated: ${JSON.stringify(formatEvent(r.data as Record<string, unknown>))}`
+        }
+
+        const r = await googleRequest('PATCH', `/calendars/${encodeURIComponent(cfg.calendarId)}/events/${eventId}`, cfg, updates)
+        if (!r.ok) return `Error: ${r.error}`
+        return `Event updated: ${JSON.stringify(formatEvent(r.data as Record<string, unknown>))}`
+      }
+
+      case 'delete': {
+        const eventId = String(normalized.eventId || normalized.id || '').trim()
+        if (!eventId) return 'Error: "eventId" is required.'
+
+        if (cfg.provider === 'outlook') {
+          const r = await outlookRequest('DELETE', `/calendar/events/${eventId}`, cfg)
+          if (!r.ok) return `Error: ${r.error}`
+          return `Event ${eventId} deleted.`
+        }
+
+        const r = await googleRequest('DELETE', `/calendars/${encodeURIComponent(cfg.calendarId)}/events/${eventId}`, cfg)
+        if (!r.ok) return `Error: ${r.error}`
+        return `Event ${eventId} deleted.`
+      }
+
+      case 'status': {
+        return JSON.stringify({
+          configured: true,
+          provider: cfg.provider,
+          calendarId: cfg.calendarId,
+          hasRefreshToken: !!cfg.refreshToken,
+        })
+      }
+
+      default:
+        return `Error: Unknown action "${action}". Use: list, create, update, delete, status.`
+    }
+  } catch (err: unknown) {
+    return `Error: ${err instanceof Error ? err.message : String(err)}`
+  }
+}
+
+const CalendarPlugin: Plugin = {
+  name: 'Calendar',
+  enabledByDefault: false,
+  description: 'Manage Google Calendar or Outlook calendar events — list, create, update, delete.',
+  hooks: {
+    getCapabilityDescription: () =>
+      'I can manage calendar events using `calendar`: list upcoming events, create new ones, update or delete existing events. Supports Google Calendar and Outlook.',
+  } as PluginHooks,
+  tools: [
+    {
+      name: 'calendar',
+      description: 'Manage calendar events. Actions: list (upcoming events), create (new event), update (modify event), delete (remove event), status (check config).',
+      parameters: {
+        type: 'object',
+        properties: {
+          action: { type: 'string', enum: ['list', 'create', 'update', 'delete', 'status'], description: 'Action to perform' },
+          summary: { type: 'string', description: 'Event title (for create/update)' },
+          description: { type: 'string', description: 'Event description (for create/update)' },
+          location: { type: 'string', description: 'Event location (for create/update)' },
+          start: { type: 'string', description: 'Start datetime in ISO 8601 format (for create/update)' },
+          end: { type: 'string', description: 'End datetime in ISO 8601 format (for create/update). Defaults to 1 hour after start.' },
+          eventId: { type: 'string', description: 'Event ID (for update/delete)' },
+          timeMin: { type: 'string', description: 'List events starting from this ISO datetime (default: now)' },
+          timeMax: { type: 'string', description: 'List events up to this ISO datetime' },
+          maxResults: { type: 'number', description: 'Max events to return (default: 20, max: 50)' },
+        },
+        required: ['action'],
+      },
+      execute: async (args) => executeCalendar(args),
+    },
+  ],
+  ui: {
+    settingsFields: [
+      {
+        key: 'provider',
+        label: 'Calendar Provider',
+        type: 'select',
+        options: [
+          { value: 'google', label: 'Google Calendar' },
+          { value: 'outlook', label: 'Microsoft Outlook' },
+        ],
+        defaultValue: 'google',
+      },
+      {
+        key: 'accessToken',
+        label: 'Access Token',
+        type: 'secret',
+        required: true,
+        placeholder: 'ya29.a0...',
+        help: 'OAuth2 access token for the calendar API. For Google: generate via OAuth2 playground or a service account.',
+      },
+      {
+        key: 'refreshToken',
+        label: 'Refresh Token (Google)',
+        type: 'secret',
+        placeholder: '1//0e...',
+        help: 'Google OAuth2 refresh token. When set, the plugin auto-refreshes expired access tokens.',
+      },
+      {
+        key: 'clientId',
+        label: 'Client ID (Google)',
+        type: 'text',
+        placeholder: '123456789.apps.googleusercontent.com',
+        help: 'Google OAuth2 client ID. Required for token refresh.',
+      },
+      {
+        key: 'clientSecret',
+        label: 'Client Secret (Google)',
+        type: 'secret',
+        placeholder: 'GOCSPX-...',
+        help: 'Google OAuth2 client secret. Required for token refresh.',
+      },
+      {
+        key: 'calendarId',
+        label: 'Calendar ID',
+        type: 'text',
+        defaultValue: 'primary',
+        placeholder: 'primary',
+        help: 'Google Calendar ID (default: "primary"). For Outlook, this is ignored.',
+      },
+    ],
+  },
+}
+
+getPluginManager().registerBuiltin('calendar', CalendarPlugin)
+
+export function buildCalendarTools(bctx: ToolBuildContext): StructuredToolInterface[] {
+  if (!bctx.hasPlugin('calendar')) return []
+
+  return [
+    tool(
+      async (args) => executeCalendar(args),
+      {
+        name: 'calendar',
+        description: CalendarPlugin.tools![0].description,
+        schema: z.object({
+          action: z.enum(['list', 'create', 'update', 'delete', 'status']).describe('Action to perform'),
+          summary: z.string().optional().describe('Event title'),
+          description: z.string().optional().describe('Event description'),
+          location: z.string().optional().describe('Event location'),
+          start: z.string().optional().describe('Start datetime (ISO 8601)'),
+          end: z.string().optional().describe('End datetime (ISO 8601)'),
+          eventId: z.string().optional().describe('Event ID (for update/delete)'),
+          timeMin: z.string().optional().describe('List events from this datetime'),
+          timeMax: z.string().optional().describe('List events until this datetime'),
+          maxResults: z.number().optional().describe('Max results (default 20, max 50)'),
+        }),
+      },
+    ),
+  ]
+}

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

@@ -88,7 +88,7 @@ getPluginManager().registerBuiltin('canvas', CanvasPlugin)
  * Legacy Bridge
  */
 export function buildCanvasTools(bctx: ToolBuildContext): StructuredToolInterface[] {
-  if (!bctx.hasTool('canvas')) return []
+  if (!bctx.hasPlugin('canvas')) return []
   return [
     tool(
       async (args) => executeCanvasAction(args, { sessionId: bctx.ctx?.sessionId || undefined }),

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

@@ -107,7 +107,9 @@ async function executeChatroomAction(args: Record<string, unknown>, context: { a
 const ChatroomPlugin: Plugin = {
   name: 'Core Chatrooms',
   description: 'Manage SwarmClaw routing rules and multi-agent chatrooms.',
-  hooks: {} as PluginHooks,
+  hooks: {
+    getCapabilityDescription: () => 'I can create and participate in chatrooms (`manage_chatrooms`) for multi-agent collaboration with @mention-based discussions.',
+  } as PluginHooks,
   tools: [
     {
       name: 'manage_chatrooms',
@@ -134,7 +136,7 @@ getPluginManager().registerBuiltin('chatroom', ChatroomPlugin)
  * Legacy Bridge
  */
 export function buildChatroomTools(bctx: ToolBuildContext): StructuredToolInterface[] {
-  if (!bctx.hasTool('manage_chatrooms')) return []
+  if (!bctx.hasPlugin('manage_chatrooms')) return []
   return [
     tool(
       async (args) => executeChatroomAction(args, { agentId: bctx.ctx?.agentId }),

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

@@ -429,7 +429,10 @@ async function executeConnectorAction(input: ConnectorActionInput, bctx: Connect
 const ConnectorPlugin: Plugin = {
   name: 'Core Connectors',
   description: 'Manage and send messages through chat platform connectors (WhatsApp, Telegram, Slack, etc.).',
-  hooks: {} as PluginHooks,
+  hooks: {
+    getCapabilityDescription: () => 'I can manage messaging channels (`manage_connectors`) — WhatsApp, Telegram, Slack, Discord — and send proactive messages via `connector_message_tool`.',
+    getOperatingGuidance: () => 'Connectors: proactive outreach for significant events only. Keep messages concise, no duplicates.',
+  } as PluginHooks,
   tools: [
     {
       name: 'connector_message_tool',
@@ -456,7 +459,7 @@ getPluginManager().registerBuiltin('connectors', ConnectorPlugin)
  * Legacy Bridge
  */
 export function buildConnectorTools(bctx: ToolBuildContext): StructuredToolInterface[] {
-  if (!bctx.hasTool('manage_connectors')) return []
+  if (!bctx.hasPlugin('manage_connectors')) return []
   return [
     tool(
       async (args) => executeConnectorAction(args as ConnectorActionInput, bctx),

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

@@ -14,20 +14,24 @@ export interface ToolContext {
 export interface SessionToolsResult {
   tools: StructuredToolInterface[]
   cleanup: () => Promise<void>
+  /** Maps tool name → plugin ID for attribution in usage tracking */
+  toolToPluginMap: Record<string, string>
 }
 
 export interface ToolBuildContext {
   cwd: string
   ctx: ToolContext | undefined
+  hasPlugin: (name: string) => boolean
+  /** @deprecated Use hasPlugin */
   hasTool: (name: string) => boolean
   cleanupFns: (() => Promise<void>)[]
   commandTimeoutMs: number
   claudeTimeoutMs: number
   cliProcessTimeoutMs: number
-  persistDelegateResumeId: (key: 'claudeCode' | 'codex' | 'opencode', id: string | null | undefined) => void
-  readStoredDelegateResumeId: (key: 'claudeCode' | 'codex' | 'opencode') => string | null
+  persistDelegateResumeId: (key: 'claudeCode' | 'codex' | 'opencode' | 'gemini', id: string | null | undefined) => void
+  readStoredDelegateResumeId: (key: 'claudeCode' | 'codex' | 'opencode' | 'gemini') => string | null
   resolveCurrentSession: () => any | null
-  activeTools: string[]
+  activePlugins: string[]
 }
 
 export function safePath(cwd: string, filePath: string): string {

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

@@ -233,12 +233,12 @@ const PLATFORM_RESOURCES: Record<string, {
 
 export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[] {
   const tools: StructuredToolInterface[] = []
-  const { cwd, ctx, hasTool } = bctx
+  const { cwd, ctx, hasPlugin } = bctx
 
   // Build dynamic agent summary for tools that need agent awareness
   const assignScope = ctx?.platformAssignScope || 'self'
   let agentSummary = ''
-  if (hasTool('manage_tasks') || hasTool('manage_schedules')) {
+  if (hasPlugin('manage_tasks') || hasPlugin('manage_schedules')) {
     if (assignScope === 'all') {
       try {
         const agents = loadAgents()
@@ -251,14 +251,14 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
   }
 
   for (const [toolKey, res] of Object.entries(PLATFORM_RESOURCES)) {
-    if (!hasTool(toolKey)) continue
+    if (!hasPlugin(toolKey)) continue
 
     let description = `Manage SwarmClaw ${res.label}. ${res.readOnly ? 'List and get only.' : 'List, get, create, update, or delete.'} Returns JSON.`
     if (toolKey === 'manage_tasks') {
       if (assignScope === 'self') {
-        description += `\n\nSet "agentId" to assign a task to yourself ("${ctx?.agentId || 'unknown'}") or leave it null. You can only assign tasks to yourself. Valid manual statuses: backlog, queued, completed, failed, archived. "running" is runtime-only and set automatically when execution starts.`
+        description += `\n\nDo NOT create tasks for yourself — just do the work directly. Tasks are for delegating work to other agents or for user-created work items. You can only list, get, update status, or complete tasks assigned to you ("${ctx?.agentId || 'unknown'}"). Valid manual statuses: backlog, queued, completed, failed, archived. "running" is runtime-only and set automatically when execution starts.`
       } else {
-        description += `\n\nSet "agentId" to assign a task to an agent (including yourself: "${ctx?.agentId || 'unknown'}"). Valid manual statuses: backlog, queued, completed, failed, archived. "running" is runtime-only and set automatically when execution starts.` + agentSummary
+        description += `\n\nDo NOT create tasks for yourself — just do the work directly. Only create tasks to delegate work to OTHER agents. Your agent ID is "${ctx?.agentId || 'unknown'}". Valid manual statuses: backlog, queued, completed, failed, archived. "running" is runtime-only and set automatically when execution starts.` + agentSummary
       }
     } else if (toolKey === 'manage_agents') {
       description += `\n\nAgents may self-edit their own soul. To update your soul, use action="update", id="${ctx?.agentId || 'your-agent-id'}", and include data with the "soul" field.`
@@ -396,6 +396,14 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
                   agents,
                 )
               }
+              // Agents cannot create tasks for themselves — just do the work directly.
+              // Tasks are for delegating to other agents or user-created work items.
+              if (toolKey === 'manage_tasks' && ctx?.agentId) {
+                const resolvedAgentId = parsed.agentId || ctx.agentId
+                if (resolvedAgentId === ctx.agentId) {
+                  return 'Error: You cannot create tasks for yourself — just do the work directly. Tasks are for delegating work to other agents. If you need to track progress, use memory instead.'
+                }
+              }
               if (toolKey === 'manage_tasks') {
                 parsed.title = deriveTaskTitle(parsed)
                 if (!parsed.title || /^untitled task$/i.test(parsed.title)) {
@@ -598,7 +606,7 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
     )
   }
 
-  if (hasTool('manage_documents')) {
+  if (hasPlugin('manage_documents')) {
     tools.push(
       tool(
         async (rawArgs) => {