@swarmclawai/swarmclaw 0.9.3 → 0.9.4

package/src/lib/server/skills/skill-discovery.ts

@@ -24,6 +24,10 @@ const LEGACY_BUNDLED_SKILLS_DIR = path.join(DATA_DIR, 'skills')
 
 let cache: DiscoveryCache | null = null
 
+export function clearDiscoveredSkillsCache(): void {
+  cache = null
+}
+
 function buildCacheKey(cwd?: string): string {
   return `${cwd || ''}`
 }

package/src/lib/server/skills/skills-normalize.test.ts

@@ -16,6 +16,8 @@ metadata:
       bins:
         - curl
     primaryEnv: GITHUB_TOKEN
+    toolNames: [github_workspace, github-cli]
+    capabilities: [github, pull-requests]
     homepage: https://example.com/github-sync
     install:
       - kind: brew
@@ -32,6 +34,8 @@ Use the GitHub API.`,
   assert.equal(normalized.version, '1.2.3')
   assert.equal(normalized.primaryEnv, 'GITHUB_TOKEN')
   assert.equal(normalized.homepage, 'https://example.com/github-sync')
+  assert.deepEqual(normalized.toolNames, ['github_workspace', 'github-cli'])
+  assert.deepEqual(normalized.capabilities, ['github', 'pull-requests'])
   assert.equal(normalized.sourceFormat, 'openclaw')
   assert.match(normalized.content, /# Sync issues/)
   assert.equal(normalized.skillRequirements?.env?.[0], 'GITHUB_TOKEN')
@@ -52,3 +56,27 @@ Run with \`process.env.GITHUB_TOKEN\` and \`process.env.OPENAI_API_KEY\`.`,
   assert.ok(normalized.security?.missingDeclarations?.includes('GITHUB_TOKEN'))
   assert.ok(normalized.security?.missingDeclarations?.includes('OPENAI_API_KEY'))
 })
+
+test('normalizeSkillPayload parses executable invocation metadata from frontmatter', () => {
+  const normalized = normalizeSkillPayload({
+    content: `---
+name: task-triage
+description: Route task triage through manage_tasks.
+invocation:
+  userInvocable: false
+command-dispatch: tool
+command-tool: manage_tasks
+command-arg-mode: raw
+---
+# Task Triage
+
+Route the request through manage_tasks.`,
+  })
+
+  assert.deepEqual(normalized.invocation, { userInvocable: false })
+  assert.deepEqual(normalized.commandDispatch, {
+    kind: 'tool',
+    toolName: 'manage_tasks',
+    argMode: 'raw',
+  })
+})

package/src/lib/server/skills/skills-normalize.ts

@@ -1,5 +1,11 @@
 import path from 'path'
-import type { SkillInstallOption, SkillRequirements, SkillSecuritySummary } from '@/types'
+import type {
+  SkillCommandDispatch,
+  SkillInstallOption,
+  SkillInvocationConfig,
+  SkillRequirements,
+  SkillSecuritySummary,
+} from '@/types'
 import { dedup } from '@/lib/shared-utils'
 
 export type SkillSourceFormat = 'openclaw' | 'plain'
@@ -17,11 +23,15 @@ type NormalizeSkillInput = {
   homepage?: unknown
   primaryEnv?: unknown
   skillKey?: unknown
+  toolNames?: unknown
+  capabilities?: unknown
   always?: unknown
   installOptions?: unknown
   skillRequirements?: unknown
   detectedEnvVars?: unknown
   security?: unknown
+  invocation?: unknown
+  commandDispatch?: unknown
   frontmatter?: unknown
 }
 
@@ -38,11 +48,15 @@ export type NormalizedSkill = {
   homepage?: string
   primaryEnv?: string | null
   skillKey?: string | null
+  toolNames?: string[]
+  capabilities?: string[]
   always?: boolean
   installOptions?: SkillInstallOption[]
   skillRequirements?: SkillRequirements
   detectedEnvVars?: string[]
   security?: SkillSecuritySummary | null
+  invocation?: SkillInvocationConfig | null
+  commandDispatch?: SkillCommandDispatch | null
   frontmatter?: Record<string, unknown> | null
 }
 
@@ -279,6 +293,65 @@ function normalizeRequirements(value: unknown): SkillRequirements | undefined {
   return normalized
 }
 
+function normalizeInvocationConfig(value: unknown): SkillInvocationConfig | null {
+  const source = asObject(value)
+  if (!source) return null
+  const userInvocable = asBoolean(source.userInvocable ?? source.user_invocable)
+  if (userInvocable === undefined) return null
+  return { userInvocable }
+}
+
+function normalizeCommandDispatch(params: {
+  frontmatter?: Record<string, unknown> | null
+  runtimeMeta?: Record<string, unknown> | null
+  input?: NormalizeSkillInput
+}): SkillCommandDispatch | null {
+  const inputDispatch = asObject(params.input?.commandDispatch)
+  const inlineDispatch = asObject(params.frontmatter?.commandDispatch)
+    || asObject(params.frontmatter?.command_dispatch)
+    || asObject(params.runtimeMeta?.commandDispatch)
+    || asObject(params.runtimeMeta?.command_dispatch)
+
+  const kindRaw = asTrimmedString(
+    inputDispatch?.kind
+      ?? inlineDispatch?.kind
+      ?? params.frontmatter?.['command-dispatch']
+      ?? params.frontmatter?.command_dispatch
+      ?? params.runtimeMeta?.['command-dispatch']
+      ?? params.runtimeMeta?.command_dispatch,
+  )
+  if (!kindRaw || kindRaw.toLowerCase() !== 'tool') return null
+
+  const toolName = asTrimmedString(
+    inputDispatch?.toolName
+      ?? inputDispatch?.tool_name
+      ?? inlineDispatch?.toolName
+      ?? inlineDispatch?.tool_name
+      ?? params.frontmatter?.['command-tool']
+      ?? params.frontmatter?.command_tool
+      ?? params.runtimeMeta?.['command-tool']
+      ?? params.runtimeMeta?.command_tool,
+  )
+  if (!toolName) return null
+
+  const argModeRaw = asTrimmedString(
+    inputDispatch?.argMode
+      ?? inputDispatch?.arg_mode
+      ?? inlineDispatch?.argMode
+      ?? inlineDispatch?.arg_mode
+      ?? params.frontmatter?.['command-arg-mode']
+      ?? params.frontmatter?.command_arg_mode
+      ?? params.runtimeMeta?.['command-arg-mode']
+      ?? params.runtimeMeta?.command_arg_mode,
+  )
+
+  return {
+    kind: 'tool',
+    toolName,
+    argMode: argModeRaw && argModeRaw.toLowerCase() === 'raw' ? 'raw' : 'raw',
+  }
+}
+
 function pickRuntimeMetadata(frontmatter: Record<string, unknown>): Record<string, unknown> | null {
   const metadata = asObject(frontmatter.metadata)
   if (metadata) {
@@ -395,11 +468,26 @@ export function normalizeSkillPayload(input: NormalizeSkillInput): NormalizedSki
   const skillKey = asTrimmedString(runtimeMeta?.skillKey)
     || asTrimmedString(input.skillKey)
     || null
+  const toolNames = asStringArray(runtimeMeta?.toolNames)
+    || asStringArray(runtimeMeta?.tools)
+    || asStringArray(input.toolNames)
+    || undefined
+  const capabilities = asStringArray(runtimeMeta?.capabilities)
+    || asStringArray(input.capabilities)
+    || undefined
   const always = asBoolean(runtimeMeta?.always) ?? asBoolean(input.always)
   const installOptions = normalizeInstallOptions(runtimeMeta?.install)
     || normalizeInstallOptions(input.installOptions)
   const skillRequirements = normalizeRequirements(runtimeMeta)
     || normalizeRequirements(input.skillRequirements)
+  const invocation = normalizeInvocationConfig(input.invocation)
+    || normalizeInvocationConfig(frontmatter?.invocation)
+    || normalizeInvocationConfig(runtimeMeta?.invocation)
+  const commandDispatch = normalizeCommandDispatch({
+    frontmatter,
+    runtimeMeta,
+    input,
+  })
 
   const sourceUrl = asTrimmedString(input.sourceUrl) || undefined
   const initialFilename = asTrimmedString(input.filename)
@@ -467,11 +555,15 @@ export function normalizeSkillPayload(input: NormalizeSkillInput): NormalizedSki
     homepage: homepage || undefined,
     primaryEnv,
     skillKey,
+    toolNames,
+    capabilities,
     always,
     installOptions,
     skillRequirements,
     detectedEnvVars: detectedEnvVars.length ? detectedEnvVars : preservedDetectedEnvVars,
     security,
+    invocation,
+    commandDispatch,
     frontmatter,
   }
 }

package/src/lib/server/storage.ts

@@ -724,7 +724,7 @@ if (!IS_BUILD_BOOTSTRAP) {
 - **Providers** — Configure LLM backends in Settings → Providers: Claude Code CLI, OpenAI Codex CLI, OpenCode CLI, Anthropic, OpenAI, Google Gemini, DeepSeek, Groq, Together AI, Mistral AI, xAI (Grok), Fireworks AI, Ollama, OpenClaw, or custom OpenAI-compatible endpoints.
 - **Tasks** — The Task Board tracks work items. Assign agents and they'll execute autonomously.
 - **Schedules** — Cron-based recurring jobs that run agents or tasks automatically.
-- **Skills** — Reusable markdown instruction files you attach to agents to specialize them.
+- **Skills** — Reusable markdown instruction files agents can discover and use by default; pin them to keep favorite workflows always-on.
 - **Connectors** — Bridge agents to Discord, Slack, Telegram, or WhatsApp.
 - **Secrets** — Encrypted vault for API keys (Settings → Secrets).
 

package/src/lib/server/tasks/task-followups.test.ts

@@ -279,6 +279,8 @@ describe('task-followups', () => {
       const sessions = {
         'sess-1': {
           id: 'sess-1',
+          name: 'connector:slack:dm',
+          user: 'connector',
           connectorContext: {
             connectorId: 'conn-1',
             channelId: 'ch-ctx',
@@ -471,6 +473,128 @@ describe('task-followups', () => {
     })
   })
 
+  describe('taskAlreadyDeliveredToConnectorTarget', () => {
+    it('returns true when the task session already delivered to the same connector target', () => {
+      const task = {
+        id: 'task-delivered',
+        title: 'Delivered task',
+        description: '',
+        agentId: 'agent-1',
+        sessionId: 'task-session',
+        status: 'completed' as const,
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+      }
+      const sessions = {
+        'task-session': {
+          id: 'task-session',
+          messages: [
+            {
+              role: 'assistant',
+              text: 'Sent it.',
+              toolEvents: [
+                {
+                  name: 'connector_message_tool',
+                  input: '{}',
+                  output: JSON.stringify({
+                    status: 'voice_sent',
+                    connectorId: 'conn-wa',
+                    to: '447700900111@s.whatsapp.net',
+                    messageId: 'msg-1',
+                  }),
+                },
+              ],
+            },
+          ],
+        },
+      }
+      const connectors = {
+        'conn-wa': {
+          id: 'conn-wa',
+          name: 'WA',
+          platform: 'whatsapp' as const,
+          agentId: 'agent-1',
+          config: {},
+          enabled: true,
+          createdAt: Date.now(),
+          updatedAt: Date.now(),
+        },
+      }
+
+      const delivered = mod.taskAlreadyDeliveredToConnectorTarget({
+        task: task as import('@/types').BoardTask,
+        target: {
+          connectorId: 'conn-wa',
+          channelId: '+44 7700 900111',
+        },
+        sessions: sessions as Record<string, import('@/lib/server/tasks/task-followups').SessionLike>,
+        connectors: connectors as Record<string, import('@/types').Connector>,
+      })
+
+      assert.equal(delivered, true)
+    })
+
+    it('returns false when connector delivery was to a different target', () => {
+      const task = {
+        id: 'task-other-target',
+        title: 'Other target',
+        description: '',
+        agentId: 'agent-1',
+        sessionId: 'task-session',
+        status: 'completed' as const,
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+      }
+      const sessions = {
+        'task-session': {
+          id: 'task-session',
+          messages: [
+            {
+              role: 'assistant',
+              text: 'Sent it.',
+              toolEvents: [
+                {
+                  name: 'connector_message_tool',
+                  input: '{}',
+                  output: JSON.stringify({
+                    status: 'sent',
+                    connectorId: 'conn-wa',
+                    to: '447700900222@s.whatsapp.net',
+                    messageId: 'msg-2',
+                  }),
+                },
+              ],
+            },
+          ],
+        },
+      }
+      const connectors = {
+        'conn-wa': {
+          id: 'conn-wa',
+          name: 'WA',
+          platform: 'whatsapp' as const,
+          agentId: 'agent-1',
+          config: {},
+          enabled: true,
+          createdAt: Date.now(),
+          updatedAt: Date.now(),
+        },
+      }
+
+      const delivered = mod.taskAlreadyDeliveredToConnectorTarget({
+        task: task as import('@/types').BoardTask,
+        target: {
+          connectorId: 'conn-wa',
+          channelId: '+44 7700 900111',
+        },
+        sessions: sessions as Record<string, import('@/lib/server/tasks/task-followups').SessionLike>,
+        connectors: connectors as Record<string, import('@/types').Connector>,
+      })
+
+      assert.equal(delivered, false)
+    })
+  })
+
   // ---- isSendableAttachment ----
 
   describe('isSendableAttachment', () => {

package/src/lib/server/tasks/task-followups.ts

@@ -1,7 +1,8 @@
 import fs from 'node:fs'
 import path from 'node:path'
-import type { BoardTask, Connector } from '@/types'
+import type { BoardTask, Connector, MessageToolEvent } from '@/types'
 import { normalizeWhatsappTarget } from '@/lib/server/connectors/response-media'
+import { isDirectConnectorSession } from '@/lib/server/connectors/session-kind'
 import { WORKSPACE_DIR } from '@/lib/server/data-dir'
 import { loadConnectors, loadSessions, UPLOAD_DIR } from '@/lib/server/storage'
 import { errorMessage } from '@/lib/shared-utils'
@@ -64,6 +65,8 @@ export interface ConnectorTaskFollowupTarget {
   threadId?: string | null
 }
 
+const CONNECTOR_DELIVERY_STATUSES = new Set(['sent', 'voice_sent'])
+
 function isEnabledFlag(value: unknown): boolean {
   if (typeof value === 'boolean') return value
   if (typeof value !== 'string') return false
@@ -223,18 +226,20 @@ export function resolveTaskOriginConnectorFollowupTarget(params: {
   const sourceSession = sessions[sourceSessionId]
   if (!sourceSession) return null
 
-  const sessionContextTarget = normalizeTarget({
-    connectorId: typeof sourceSession.connectorContext?.connectorId === 'string'
-      ? sourceSession.connectorContext.connectorId
-      : null,
-    channelId: typeof sourceSession.connectorContext?.channelId === 'string'
-      ? sourceSession.connectorContext.channelId
-      : null,
-    threadId: typeof sourceSession.connectorContext?.threadId === 'string'
-      ? sourceSession.connectorContext.threadId
-      : null,
-  })
-  if (sessionContextTarget) return sessionContextTarget
+  if (isDirectConnectorSession(sourceSession)) {
+    const sessionContextTarget = normalizeTarget({
+      connectorId: typeof sourceSession.connectorContext?.connectorId === 'string'
+        ? sourceSession.connectorContext.connectorId
+        : null,
+      channelId: typeof sourceSession.connectorContext?.channelId === 'string'
+        ? sourceSession.connectorContext.channelId
+        : null,
+      threadId: typeof sourceSession.connectorContext?.threadId === 'string'
+        ? sourceSession.connectorContext.threadId
+        : null,
+    })
+    if (sessionContextTarget) return sessionContextTarget
+  }
 
   if (!Array.isArray(sourceSession.messages)) return null
 
@@ -312,6 +317,68 @@ export function collectTaskConnectorFollowupTargets(params: {
   return targets
 }
 
+function normalizeFollowupChannelForConnector(connector: Connector | undefined, channelId: string | null | undefined): string {
+  const raw = typeof channelId === 'string' ? channelId.trim() : ''
+  if (!raw) return ''
+  return connector?.platform === 'whatsapp' ? normalizeWhatsappTarget(raw) : raw
+}
+
+function extractDeliveredConnectorTarget(event: MessageToolEvent | null | undefined): {
+  connectorId: string
+  channelId: string
+} | null {
+  if (!event || event.name !== 'connector_message_tool' || event.error === true || !event.output) return null
+  try {
+    const parsed = JSON.parse(event.output) as Record<string, unknown>
+    const status = typeof parsed.status === 'string' ? parsed.status.trim().toLowerCase() : ''
+    const connectorId = typeof parsed.connectorId === 'string' ? parsed.connectorId.trim() : ''
+    const channelId = typeof parsed.to === 'string' ? parsed.to.trim() : ''
+    if (!CONNECTOR_DELIVERY_STATUSES.has(status) || !connectorId || !channelId) return null
+    return { connectorId, channelId }
+  } catch {
+    return null
+  }
+}
+
+export function taskAlreadyDeliveredToConnectorTarget(params: {
+  task: BoardTask
+  target: ConnectorTaskFollowupTarget
+  sessions: Record<string, SessionLike>
+  connectors: Record<string, Connector>
+}): boolean {
+  const taskRecord = params.task as BoardTask & {
+    checkpoint?: {
+      lastSessionId?: string | null
+    } | null
+  }
+  const taskSessionId = typeof taskRecord.sessionId === 'string' && taskRecord.sessionId.trim()
+    ? taskRecord.sessionId.trim()
+    : typeof taskRecord.checkpoint?.lastSessionId === 'string' && taskRecord.checkpoint.lastSessionId.trim()
+      ? taskRecord.checkpoint.lastSessionId.trim()
+      : ''
+  if (!taskSessionId) return false
+  const session = params.sessions[taskSessionId]
+  if (!session || !Array.isArray(session.messages)) return false
+
+  const connector = params.connectors[params.target.connectorId]
+  const normalizedTargetChannel = normalizeFollowupChannelForConnector(connector, params.target.channelId)
+  if (!normalizedTargetChannel) return false
+
+  for (let index = session.messages.length - 1; index >= 0; index -= 1) {
+    const message = session.messages[index]
+    if (!message || message.role !== 'assistant' || !Array.isArray(message.toolEvents)) continue
+    for (const event of message.toolEvents) {
+      const delivered = extractDeliveredConnectorTarget(event as MessageToolEvent)
+      if (!delivered) continue
+      if (delivered.connectorId !== params.target.connectorId) continue
+      const normalizedDeliveredChannel = normalizeFollowupChannelForConnector(connector, delivered.channelId)
+      if (normalizedDeliveredChannel === normalizedTargetChannel) return true
+    }
+  }
+
+  return false
+}
+
 export async function notifyConnectorTaskFollowups(params: {
   task: BoardTask
   statusLabel: string
@@ -347,6 +414,14 @@ export async function notifyConnectorTaskFollowups(params: {
   for (const target of targets) {
     const connector = connectors[target.connectorId]
     if (!connector) continue
+    if (taskAlreadyDeliveredToConnectorTarget({
+      task,
+      target,
+      sessions: sessions as Record<string, SessionLike>,
+      connectors: connectors as Record<string, Connector>,
+    })) {
+      continue
+    }
 
     const template = typeof (connector as any).config?.taskFollowupTemplate === 'string'
       ? (connector as any).config.taskFollowupTemplate.trim()

package/src/types/index.ts

@@ -49,6 +49,15 @@ export interface SessionArchiveState {
   exportPath?: string | null
 }
 
+export interface SessionSkillRuntimeState {
+  selectedSkillId?: string | null
+  selectedSkillName?: string | null
+  selectedAt?: number | null
+  lastAction?: 'select' | 'load' | 'run' | null
+  lastRunAt?: number | null
+  lastRunToolName?: string | null
+}
+
 export interface CanvasMetricItem {
   label: string
   value: string
@@ -234,6 +243,7 @@ export interface Session {
   lastSessionResetReason?: string | null
   identityState?: IdentityContinuityState | null
   sessionArchiveState?: SessionArchiveState | null
+  skillRuntimeState?: SessionSkillRuntimeState | null
   pinned?: boolean
   file?: string | null
   queuedCount?: number
@@ -642,8 +652,8 @@ export interface Agent {
   plugins?: string[]             // e.g. ['browser', 'memory'] — enabled plugin IDs
   /** @deprecated Use `plugins` instead. Kept for backward compat with stored data. */
   tools?: string[]
-  skills?: string[]             // e.g. ['frontend-design'] — Claude Code skills to use
-  skillIds?: string[]           // IDs of uploaded skills from the Skills manager
+  skills?: string[]             // e.g. ['frontend-design'] — pinned Claude Code skills to mention explicitly
+  skillIds?: string[]           // IDs of pinned managed skills to keep always-on for this agent
   mcpServerIds?: string[]       // IDs of configured MCP servers to inject tools from
   mcpDisabledTools?: string[]   // MCP tool names disabled for this agent (denylist)
   capabilities?: string[]       // e.g. ['frontend', 'screenshots', 'research', 'devops']
@@ -1675,11 +1685,15 @@ export interface Skill {
   homepage?: string
   primaryEnv?: string | null
   skillKey?: string | null
+  toolNames?: string[]
+  capabilities?: string[]
   always?: boolean
   installOptions?: SkillInstallOption[]
   skillRequirements?: SkillRequirements
   detectedEnvVars?: string[]
   security?: SkillSecuritySummary | null
+  invocation?: SkillInvocationConfig | null
+  commandDispatch?: SkillCommandDispatch | null
   frontmatter?: Record<string, unknown> | null
   scope?: 'global' | 'agent'
   agentIds?: string[]
@@ -1687,6 +1701,16 @@ export interface Skill {
   updatedAt: number
 }
 
+export interface SkillInvocationConfig {
+  userInvocable?: boolean
+}
+
+export interface SkillCommandDispatch {
+  kind: 'tool'
+  toolName: string
+  argMode?: 'raw'
+}
+
 export interface SkillSecuritySummary {
   level: 'low' | 'medium' | 'high'
   notes: string[]