@swarmclawai/swarmclaw 0.9.3 → 0.9.4

package/src/lib/server/chat-execution/stream-agent-chat.ts

@@ -9,8 +9,7 @@ import { loadSettings, loadAgents, loadSkills, appendUsage } from '@/lib/server/
 import { estimateCost, buildPluginDefinitionCosts } from '@/lib/server/cost'
 import { getPluginManager } from '@/lib/server/plugins'
 import { loadRuntimeSettings, getAgentLoopRecursionLimit } from '@/lib/server/runtime/runtime-settings'
-import { buildSkillPromptText } from '@/lib/server/skills/skill-prompt-budget'
-import { buildDiscoveredSkillPromptText, collectPluginMatchedDiscoveredSkills } from '@/lib/server/skills/discovered-skill-prompt'
+import { buildRuntimeSkillPromptBlocks, resolveRuntimeSkills } from '@/lib/server/skills/runtime-skill-resolver'
 
 import { logExecution } from '@/lib/server/execution-log'
 import { buildCurrentDateTimePromptContext } from '@/lib/server/prompt-runtime-context'
@@ -22,6 +21,7 @@ import { enqueueSystemEvent } from '@/lib/server/runtime/system-events'
 import { resolveActiveProjectContext } from '@/lib/server/project-context'
 import { resolveImagePath } from '@/lib/server/resolve-image'
 import { routeTaskIntent } from '@/lib/server/capability-router'
+import { isDirectConnectorSession } from '@/lib/server/connectors/session-kind'
 import {
   getEnabledToolPlanningView,
   getFirstToolForCapability,
@@ -97,6 +97,30 @@ export {
   resolveContinuationAssistantText,
 }
 
+const TOOL_SUMMARY_SHORT_RESPONSE_EXEMPT_TOOLS = new Set([
+  'use_skill',
+])
+
+export function shouldSkipToolSummaryForShortResponse(params: {
+  fullText: string
+  toolEvents: MessageToolEvent[]
+  isConnectorSession?: boolean
+}): boolean {
+  if (params.isConnectorSession) return false
+  if (!params.fullText.trim()) return false
+  if (!Array.isArray(params.toolEvents) || params.toolEvents.length === 0) return false
+  const toolNames = Array.from(new Set(
+    params.toolEvents
+      .map((event) => canonicalizePluginId(event.name) || event.name)
+      .filter((name): name is string => typeof name === 'string' && name.trim().length > 0),
+  ))
+  if (toolNames.length === 0) return false
+  // Skill runtime tools load guidance into context rather than producing external
+  // evidence that needs a forced synthesis pass. A short exact answer after those
+  // calls can already be the correct completion.
+  return toolNames.every((toolName) => TOOL_SUMMARY_SHORT_RESPONSE_EXEMPT_TOOLS.has(toolName))
+}
+
 /** Extract a breadcrumb title from notable tool completions (task/schedule/agent creation). */
 interface StreamAgentChatOpts {
   session: Session
@@ -380,6 +404,21 @@ function buildAgenticExecutionPolicy(opts: {
       'Do not use `manage_tasks`, `manage_agents`, or `delegate` as a substitute for a direct memory write or recall step.',
     )
   }
+  if (hasTooling) {
+    parts.push(
+      '## Skill Runtime',
+      'When the skill runtime section lists a fitting reusable workflow, use `use_skill` to select it before falling back to generic exploration.',
+      'Prefer `use_skill` action `run` for executable skills and `use_skill` action `load` only when the skill is guidance-only.',
+    )
+  }
+  if (opts.enabledPlugins.some((toolId) => (canonicalizePluginId(toolId) || toolId) === 'manage_skills')) {
+    parts.push(
+      '## Skill Resolution',
+      'When you are blocked on a missing capability, binary, or environment setup, call `manage_skills` before repeating generic exploration.',
+      'Use `manage_skills` action `recommend_for_task` or `status` to find a fitting local skill. If a fitting skill needs installation, request the explicit install approval through `manage_skills` and stop retrying the same blocker.',
+      'Do not silently install skills during autonomous runs. Installation is explicit and approval-gated.',
+    )
+  }
   if (opts.hasAttachmentContext) {
     parts.push(
       '## Attachments',
@@ -492,7 +531,7 @@ export async function streamAgentChat(opts: StreamAgentChatOpts): Promise<Stream
 async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAgentChatResult> {
   const startTs = Date.now()
   const { session, message, imagePath, imageUrl, attachedFiles, apiKey, systemPrompt, write, history, fallbackCredentialIds, signal } = opts
-  const isConnectorSession = !!session.connectorContext?.connectorId
+  const isConnectorSession = isDirectConnectorSession(session)
   const rawPlugins = Array.isArray(session.plugins) ? session.plugins : []
   const hasShellCapability = rawPlugins.some((toolId) => ['shell', 'execute_command'].includes(String(toolId)))
   const sessionPlugins = expandPluginIds([
@@ -582,27 +621,16 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
       if (continuityBlock) promptParts.push(continuityBlock)
       if (agent?.soul) promptParts.push(agent.soul)
       if (agent?.systemPrompt) promptParts.push(agent.systemPrompt)
-      const allSkills = loadSkills()
-      if (agent?.skillIds?.length) {
-        const skillPromptText = buildSkillPromptText(allSkills, agent.skillIds)
-        if (skillPromptText) promptParts.push(skillPromptText)
-      }
-
-      // Auto-discover workspace/bundled skills. If one matches an enabled plugin,
-      // inject the full skill content so the agent can use that tool more precisely.
       try {
-        const { discoverSkills } = await import('@/lib/server/skills/skill-discovery')
-        const discovered = discoverSkills({ cwd: session.cwd })
-        if (discovered.length > 0) {
-          const { matched, remaining } = collectPluginMatchedDiscoveredSkills(discovered, sessionPlugins, allSkills)
-          const discoveredPromptText = buildDiscoveredSkillPromptText(matched)
-          if (discoveredPromptText) promptParts.push(discoveredPromptText)
-
-          const discoveredBlock = remaining
-            .map(s => `- **${s.name}**: ${(s.description || '').slice(0, 120)}`)
-            .join('\n')
-          if (discoveredBlock) promptParts.push(`## Available Skills\n${discoveredBlock}`)
-        }
+        const allSkills = loadSkills()
+        const runtimeSkills = resolveRuntimeSkills({
+          cwd: session.cwd,
+          enabledPlugins: sessionPlugins,
+          agentSkillIds: agent?.skillIds || [],
+          storedSkills: allSkills,
+          selectedSkillId: session.skillRuntimeState?.selectedSkillId || null,
+        })
+        promptParts.push(...buildRuntimeSkillPromptBlocks(runtimeSkills))
       } catch { /* non-critical */ }
     }
   }
@@ -1555,7 +1583,16 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
       // However, if tools already produced results but the model has no/trivial text,
       // we attempt a tool_summary continuation instead of just erroring out.
       if (loopDetectionTriggered) {
-        const loopTextIsTrivial = !fullText.trim() || (fullText.trim().length < 150 && streamedToolEvents.length >= 2)
+        const skipToolSummaryForShortResponse = shouldSkipToolSummaryForShortResponse({
+          fullText,
+          toolEvents: streamedToolEvents,
+          isConnectorSession,
+        })
+        const loopTextIsTrivial = !fullText.trim() || (
+          !skipToolSummaryForShortResponse
+          && fullText.trim().length < 150
+          && streamedToolEvents.length >= 2
+        )
         if (loopTextIsTrivial && streamedToolEvents.length > 0 && toolSummaryRetryCount < MAX_TOOL_SUMMARY_RETRIES) {
           // Override: let the tool_summary check below handle it instead of breaking
           loopDetectionTriggered = null
@@ -1715,8 +1752,14 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
       // Triggers when: (a) text is empty, or (b) text is trivially short (< 150 chars)
       // and multiple tools ran — the agent likely emitted a "I'll do X" preamble but
       // never synthesized the tool outputs into a real response.
+      const skipToolSummaryForShortResponse = shouldSkipToolSummaryForShortResponse({
+        fullText,
+        toolEvents: streamedToolEvents,
+        isConnectorSession,
+      })
       const textIsTrivial = !fullText.trim() || (
-        !isConnectorSession && fullText.trim().length < 150
+        !skipToolSummaryForShortResponse
+        && !isConnectorSession && fullText.trim().length < 150
         && (
           streamedToolEvents.length >= 2
           || likelyResearchSynthesisTask
@@ -1728,6 +1771,7 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
         && hasToolCalls
         && textIsTrivial
         && streamedToolEvents.length > 0
+        && !skipToolSummaryForShortResponse
         && toolSummaryRetryCount < MAX_TOOL_SUMMARY_RETRIES
       ) {
         shouldContinue = 'tool_summary'

package/src/lib/server/chatrooms/chatroom-helpers.test.ts

@@ -1,3 +1,6 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
 import { describe, it } from 'node:test'
 import assert from 'node:assert/strict'
 import type { Agent, Chatroom } from '@/types'
@@ -9,6 +12,7 @@ import {
   resolveChatroomWorkspaceDir,
   resolveAgentApiEndpoint,
   resolveReplyTargetAgentId,
+  buildAgentSystemPromptForChatroom,
 } from '@/lib/server/chatrooms/chatroom-helpers'
 
 function makeAgents(): Record<string, Agent> {
@@ -163,4 +167,26 @@ describe('chatroom-helpers', () => {
     assert.equal(cwd, resolveChatroomWorkspaceDir('room-safe'))
     assert.match(cwd, /chatrooms[\/\\]room-safe$/)
   })
+
+  it('includes discoverable local skills in chatroom prompts even when none are pinned', () => {
+    const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-chatroom-skill-'))
+    try {
+      const skillDir = path.join(cwd, 'skills', 'chatroom-default-skill')
+      fs.mkdirSync(skillDir, { recursive: true })
+      fs.writeFileSync(path.join(skillDir, 'SKILL.md'), `---
+name: chatroom-default-skill
+description: Local chatroom skill.
+---
+# Chatroom Default Skill
+
+Prefer this chatroom workflow when it fits.
+`)
+
+      const prompt = buildAgentSystemPromptForChatroom(makeAgents().default, cwd)
+      assert.match(prompt, /discoverable by default/i)
+      assert.match(prompt, /chatroom-default-skill/i)
+    } finally {
+      fs.rmSync(cwd, { recursive: true, force: true })
+    }
+  })
 })

package/src/lib/server/chatrooms/chatroom-helpers.ts

@@ -9,6 +9,7 @@ import { getProvider } from '@/lib/providers'
 import { normalizeProviderEndpoint } from '@/lib/openclaw/openclaw-endpoint'
 import { WORKSPACE_DIR } from '@/lib/server/data-dir'
 import { applyResolvedRoute, resolvePrimaryAgentRoute } from '@/lib/server/agents/agent-runtime-config'
+import { buildRuntimeSkillPromptBlocks, resolveRuntimeSkills } from '@/lib/server/skills/runtime-skill-resolver'
 import type { Chatroom, ChatroomMember, Agent, Session, Message, ChatroomMessage } from '@/types'
 
 /** Resolve API key from an agent's credentialId */
@@ -324,7 +325,7 @@ export function appendSyntheticSessionMessage(
 }
 
 /** Build agent's system prompt including skills and identity context */
-export function buildAgentSystemPromptForChatroom(agent: Agent): string {
+export function buildAgentSystemPromptForChatroom(agent: Agent, cwd?: string | null): string {
   const settings = loadSettings()
   const parts: string[] = []
 
@@ -358,13 +359,15 @@ export function buildAgentSystemPromptForChatroom(agent: Agent): string {
   if (agent.systemPrompt) parts.push(`## System Prompt\n${agent.systemPrompt}`)
 
   // 5. Skills (SwarmClaw Core)
-  if (agent.skillIds?.length) {
-    const allSkills = loadSkills()
-    for (const skillId of agent.skillIds) {
-      const skill = allSkills[skillId]
-      if (skill?.content) parts.push(`## Skill: ${skill.name}\n${skill.content}`)
-    }
-  }
+  try {
+    const runtimeSkills = resolveRuntimeSkills({
+      cwd,
+      enabledPlugins: agent.plugins || agent.tools || [],
+      agentSkillIds: agent.skillIds || [],
+      storedSkills: loadSkills(),
+    })
+    parts.push(...buildRuntimeSkillPromptBlocks(runtimeSkills))
+  } catch { /* non-critical */ }
 
   // 6. Thinking & Output Format (OpenClaw Style)
   const thinkingHint = [

package/src/lib/server/connectors/contact-boundaries.ts

@@ -0,0 +1,101 @@
+import type { Agent, Session, MemoryEntry, Connector } from '@/types'
+import { getMemoryDb } from '@/lib/server/memory/memory-db'
+import { dedup } from '@/lib/shared-utils'
+import { isReplyToLastOutbound, textMentionsAlias } from './policy'
+import type { InboundMessage } from './types'
+
+function toDigits(raw: string): string {
+  const stripped = raw.replace(/@.*$/, '').replace(/[^\d]/g, '')
+  if (stripped.startsWith('0') && stripped.length >= 10) return `44${stripped.slice(1)}`
+  return stripped
+}
+
+function collectSenderIds(
+  msg: InboundMessage,
+  session?: Partial<Session> | null,
+): string[] {
+  return dedup([
+    msg.senderId,
+    msg.senderIdAlt,
+    msg.channelId,
+    msg.channelIdAlt,
+    ...(Array.isArray(session?.connectorContext?.allKnownPeerIds) ? session.connectorContext.allKnownPeerIds : []),
+  ].filter((value): value is string => typeof value === 'string' && value.trim().length > 0))
+}
+
+function memoryMatchesSender(entry: MemoryEntry, senderIds: string[], senderName: string): boolean {
+  const title = String(entry.title || '').toLowerCase()
+  const content = String(entry.content || '').toLowerCase()
+  const normalizedSenderName = senderName.trim().toLowerCase()
+
+  for (const rawId of senderIds) {
+    const lowered = rawId.toLowerCase()
+    if (lowered && (title.includes(lowered) || content.includes(lowered))) return true
+  }
+
+  const senderDigits = new Set(senderIds.map(toDigits).filter((value) => value.length >= 6))
+  const memoryDigits = [
+    ...(String(entry.content || '').match(/(?:\+?\d[\d\s\-().]{6,}\d)/g) || []).map(toDigits),
+    ...(Array.isArray((entry.metadata as Record<string, unknown> | undefined)?.identifiers)
+      ? ((entry.metadata as Record<string, unknown>).identifiers as unknown[])
+        .filter((value): value is string => typeof value === 'string')
+        .map(toDigits)
+      : []),
+  ].filter((value) => value.length >= 6)
+
+  for (const memoryDigit of memoryDigits) {
+    for (const senderDigit of senderDigits) {
+      if (senderDigit.endsWith(memoryDigit) || memoryDigit.endsWith(senderDigit)) return true
+    }
+  }
+
+  if (!normalizedSenderName) return false
+  return title.includes(normalizedSenderName) || content.includes(normalizedSenderName)
+}
+
+function memoryDefinesQuietBoundary(entry: MemoryEntry): boolean {
+  const text = `${entry.title || ''}\n${entry.content || ''}`.toLowerCase()
+  const boundaryRule = /\b(?:do not respond|do not reply|don't respond|don't reply|no replies|stay quiet|stay silent|remain quiet|be quiet)\b[\s\S]{0,140}\bunless\b/i
+  const directAddressRule = /\b(?:address(?:es|ed)?|mention(?:s|ed)?|refer(?:s|red)?|talk(?:ing)? to)\b[\s\S]{0,80}\bhal\b/i
+  const verifyRule = /\bverify whether\b[\s\S]{0,80}\b(?:wayde|hal)\b/i
+  return boundaryRule.test(text) && (directAddressRule.test(text) || verifyRule.test(text))
+}
+
+function buildDirectAddressAliases(agent: Partial<Agent> | null | undefined, connector: Partial<Connector> | null | undefined): string[] {
+  const agentName = typeof agent?.name === 'string' ? agent.name.trim() : ''
+  const connectorName = typeof connector?.name === 'string' ? connector.name.trim() : ''
+  const aliases = [agentName, connectorName]
+  const firstWord = agentName.split(/\s+/)[0] || ''
+  if (firstWord) aliases.push(firstWord)
+  if (agentName.toLowerCase().includes('hal')) aliases.push('Hal')
+  return dedup(aliases.filter(Boolean))
+}
+
+export function enforceSenderQuietBoundary(params: {
+  agent?: Partial<Agent> | null
+  connector?: Partial<Connector> | null
+  session?: Partial<Session> | null
+  msg: InboundMessage
+}): { suppress: boolean; memoryTitle?: string } {
+  const { agent, connector, session, msg } = params
+  if (!agent?.id || msg.isGroup) return { suppress: false }
+
+  const senderIds = collectSenderIds(msg, session)
+  const senderName = typeof msg.senderName === 'string' ? msg.senderName : ''
+  if (senderIds.length === 0 && !senderName.trim()) return { suppress: false }
+
+  const memDb = getMemoryDb()
+  const memories = memDb.list(agent.id, 200).filter((entry) =>
+    entry.category?.startsWith('identity/')
+    && memoryMatchesSender(entry, senderIds, senderName),
+  )
+  const matchedBoundary = memories.find(memoryDefinesQuietBoundary)
+  if (!matchedBoundary) return { suppress: false }
+
+  const explicitlyAddressed = textMentionsAlias(msg.text || '', buildDirectAddressAliases(agent, connector))
+    || isReplyToLastOutbound(msg, session)
+
+  return explicitlyAddressed
+    ? { suppress: false }
+    : { suppress: true, memoryTitle: matchedBoundary.title }
+}