@swarmclawai/swarmclaw 0.9.2 → 0.9.4

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

@@ -1,6 +1,7 @@
 import fs from 'fs'
 import { HumanMessage, AIMessage } from '@langchain/core/messages'
 import { createReactAgent } from '@langchain/langgraph/prebuilt'
+import { MemorySaver } from '@langchain/langgraph'
 import { DEFAULT_HEARTBEAT_INTERVAL_SEC } from '@/lib/runtime/heartbeat-defaults'
 import { buildSessionTools } from '@/lib/server/session-tools'
 import { buildChatModel } from '@/lib/server/build-llm'
@@ -8,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'
@@ -21,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,
@@ -51,31 +52,43 @@ import {
 import type { ContinuationType } from '@/lib/server/chat-execution/stream-continuation'
 import { dedup, errorMessage, sleep } from '@/lib/shared-utils'
 import { perf } from '@/lib/server/runtime/perf'
-import { getCheckpointSaver } from '@/lib/server/langgraph-checkpoint'
 import {
   compactThreadRecallText,
   getExplicitRequiredToolNames,
   getWalletApprovalBoundaryAction,
-  isNarrowDirectMemoryWriteTurn,
   isWalletSimulationResult,
   resolveToolAction,
-  shouldAllowToolForDirectMemoryWrite,
-  shouldAllowToolForCurrentThreadRecall,
   shouldForceExternalServiceSummary,
   shouldTerminateOnSuccessfulMemoryMutation,
   updateStreamedToolEvents,
 } from '@/lib/server/chat-execution/chat-streaming-utils'
 import { LangGraphToolEventTracker } from '@/lib/server/chat-execution/tool-event-tracker'
 
+// LangGraph's streamEvents leaves dangling internal promises when the for-await
+// loop exits early (break on tool loop detection, execution boundary, etc.).
+// These promises may later reject with GraphRecursionError or AbortError.
+// Register a permanent handler to prevent process crashes from these expected
+// background rejections.  Only LangGraph-specific errors (identified by
+// pregelTaskId or lc_error_code) are suppressed; all other rejections propagate
+// normally.
+process.on('unhandledRejection', (err: unknown) => {
+  if (
+    err && typeof err === 'object'
+    && ('pregelTaskId' in err
+      || (err instanceof Error && (err.name === 'AbortError' || err.name === 'GraphRecursionError'))
+      || (err as Record<string, unknown>).lc_error_code === 'GRAPH_RECURSION_LIMIT')
+  ) {
+    // Silently suppress — expected background rejection from LangGraph
+    return
+  }
+})
+
 // Re-export continuation functions so existing consumers don't need to change imports
 export {
   getExplicitRequiredToolNames,
-  isNarrowDirectMemoryWriteTurn,
   isWalletSimulationResult,
   looksLikeOpenEndedDeliverableTask,
   shouldForceRecoverableToolErrorFollowthrough,
-  shouldAllowToolForDirectMemoryWrite,
-  shouldAllowToolForCurrentThreadRecall,
   shouldForceExternalExecutionFollowthrough,
   shouldForceDeliverableFollowthrough,
   shouldForceExternalServiceSummary,
@@ -84,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
@@ -101,9 +138,6 @@ interface StreamAgentChatOpts {
 
 // LangGraph uses this internal configurable key to bypass subgraph lookup when
 // resolving state from a namespaced checkpoint. It is not exported publicly in
-// @langchain/langgraph 1.x, so keep the literal here instead of importing a
-// non-exported symbol that breaks Next compilation.
-const LANGGRAPH_CHECKPOINTER_CONFIG_KEY = '__pregel_checkpointer'
 const CONTEXT_WARNING_OVERHEAD_TOKENS = 192
 
 /** Extract HTTP status code and Retry-After from provider error objects (OpenAI SDK, etc.) */
@@ -341,7 +375,6 @@ function buildAgenticExecutionPolicy(opts: {
   const pluginLines = buildPluginCapabilityLines(opts.enabledPlugins, { platformAssignScope: opts.platformAssignScope })
   const toolDisciplineLines = buildToolDisciplineLines(opts.enabledPlugins)
   const hasMemoryTools = opts.enabledPlugins.some((toolId) => (canonicalizePluginId(toolId) || toolId) === 'memory')
-  const directMemoryWriteOnlyTurn = Boolean(opts.userMessage && isNarrowDirectMemoryWriteTurn(opts.userMessage))
 
   const parts: string[] = []
 
@@ -371,10 +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 (hasMemoryTools && directMemoryWriteOnlyTurn) {
-    parts.push(buildDirectMemoryWriteBlock())
+  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',
@@ -393,6 +437,7 @@ function buildAgenticExecutionPolicy(opts: {
     'Execute by default — only confirm on high-risk actions.',
     'If a tool errors, retry or explain the blocker. Never claim success without evidence.',
     'Keep responses concise. Bullet points over prose. After file operations, confirm the result briefly (path and status) without echoing the full file contents.',
+    'Do not end every reply with a question. Only ask when a specific missing detail blocks progress. When a task is done, state the result and stop.',
     opts.responseStyle === 'concise'
       ? `IMPORTANT: Be extremely concise.${opts.responseMaxChars ? ` Keep responses under ${opts.responseMaxChars} characters.` : ' Target under 500 characters.'} Lead with the answer, skip preamble.`
       : opts.responseStyle === 'detailed'
@@ -458,16 +503,6 @@ function buildCurrentThreadRecallBlock(history: Message[]): string {
   return lines.join('\n')
 }
 
-function buildDirectMemoryWriteBlock(): string {
-  return [
-    '## Direct Memory Write',
-    'This turn is a direct request to remember, store, or correct a durable fact.',
-    'Call `memory_store` or `memory_update` immediately, then confirm the stored value succinctly.',
-    'If the user bundled several related facts into one remember request, store them together in one canonical memory write unless they explicitly asked for separate entries.',
-    'Do not inspect skills, browse the workspace, request capabilities, manage tasks, manage agents, or delegate before the direct memory write is complete.',
-  ].join('\n')
-}
-
 export interface StreamAgentChatResult {
   /** All text accumulated across every LLM turn (for SSE / web UI history). */
   fullText: string
@@ -496,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([
@@ -543,8 +578,7 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
 
   const promptParts: string[] = []
   const hasProvidedSystemPrompt = typeof systemPrompt === 'string' && systemPrompt.trim().length > 0
-  const directMemoryWriteOnlyTurn = isNarrowDirectMemoryWriteTurn(message)
-  const currentThreadRecallRequest = !directMemoryWriteOnlyTurn && isCurrentThreadRecallRequest(message)
+  const currentThreadRecallRequest = isCurrentThreadRecallRequest(message)
   const hasAttachmentContext = Boolean(
     imagePath
     || attachedFiles?.length
@@ -587,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 */ }
     }
   }
@@ -653,8 +676,8 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
   try {
     const pluginContextParts = await getPluginManager().collectAgentContext(session, sessionPlugins, message, history)
     promptParts.push(...pluginContextParts)
-  } catch {
-    // Plugin context injection is non-critical
+  } catch (err: unknown) {
+    console.error('[stream-agent-chat] Plugin context injection failed:', err instanceof Error ? err.message : String(err))
   }
 
   if (!hasProvidedSystemPrompt && activeProjectContext.projectId) {
@@ -757,7 +780,7 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
 
   // Proactive memory recall: inject relevant memories into context before LLM invocation
   // Skips heartbeat polls, very short messages, and thread-recall requests (which use chat history instead)
-  if (session.agentId && !directMemoryWriteOnlyTurn && !currentThreadRecallRequest && message.length > 12) {
+  if (session.agentId && !currentThreadRecallRequest && message.length > 12) {
     try {
       const agents = loadAgents()
       const agentForMemory = agents[session.agentId]
@@ -794,23 +817,6 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
     memoryScopeMode: agentMemoryScopeMode,
   })
   endToolBuildPerf({ toolCount: tools.length })
-  const toolsForTurn = currentThreadRecallRequest
-    ? tools.filter((tool) => {
-        const toolName = typeof (tool as { name?: unknown }).name === 'string'
-          ? String((tool as { name?: unknown }).name)
-          : ''
-        return shouldAllowToolForCurrentThreadRecall(toolName)
-      })
-    : directMemoryWriteOnlyTurn
-      ? tools.filter((tool) => {
-          const toolName = typeof (tool as { name?: unknown }).name === 'string'
-            ? String((tool as { name?: unknown }).name)
-            : ''
-          return shouldAllowToolForDirectMemoryWrite(toolName)
-        })
-      : tools
-  const checkpointNamespace = `chat:${startTs}`
-  const checkpointSaver = getCheckpointSaver()
   const recursionLimit = getAgentLoopRecursionLimit(runtime)
 
   // Build message history for context
@@ -997,11 +1003,17 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
     // Warning failure is non-critical
   }
 
+  // Use a fresh in-memory checkpointer instead of the SQLite one.  We manage
+  // conversation history externally via langchainMessages — each iteration
+  // receives full history, so no cross-iteration checkpoint state is needed.
+  // MemorySaver avoids the SQLite serde round-trip that dropped tool_call IDs
+  // or ToolMessages, causing OpenAI to reject with "tool_calls must be
+  // followed by tool messages" errors.
   const agent = createReactAgent({
     llm,
-    tools: toolsForTurn,
+    tools,
     prompt,
-    checkpointer: checkpointSaver,
+    checkpointer: new MemorySaver(),
   })
 
   const langchainMessages: Array<HumanMessage | AIMessage> = []
@@ -1018,7 +1030,6 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
   const currentContent = await buildLangChainContent(message, imagePath, attachedFiles)
   langchainMessages.push(new HumanMessage({ content: currentContent }))
   let pendingGraphMessages = [...langchainMessages]
-  let currentCheckpointId: string | undefined
 
   let fullText = ''
   let lastSegment = ''
@@ -1073,7 +1084,7 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
     MAX_TOOL_SUMMARY_RETRIES = 1
     MAX_UNFINISHED_TOOL_FOLLOWTHROUGHS = 1
   }
-  const REQUIRED_TOOL_KICKOFF_TIMEOUT_MS = 20_000
+  const REQUIRED_TOOL_KICKOFF_TIMEOUT_MS = runtime.requiredToolKickoffMs
   let autoContinueCount = 0
   let transientRetryCount = 0
   let pendingRetryAfterMs: number | null = null
@@ -1154,7 +1165,7 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
         idleTimer = setTimeout(() => {
           idleTimedOut = true
           iterationController.abort()
-        }, 90_000)
+        }, runtime.streamIdleStallMs)
       }
 
       const armRequiredToolKickoff = () => {
@@ -1175,23 +1186,21 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
       const toolPerfEnds = new Map<string, (extra?: Record<string, unknown>) => number>()
       const iterationInputMessages = pendingGraphMessages
       let iterationSucceeded = false
+      const eventStream = agent.streamEvents(
+        { messages: iterationInputMessages },
+        {
+          version: 'v2',
+          recursionLimit,
+          signal: iterationController.signal,
+          configurable: {
+            thread_id: `${session.id}:${startTs}:${iteration}`,
+          },
+        },
+      )
 
       try {
         armIdleWatchdog()
         armRequiredToolKickoff()
-        const eventStream = agent.streamEvents(
-          { messages: iterationInputMessages },
-          {
-            version: 'v2',
-            recursionLimit,
-            signal: iterationController.signal,
-            configurable: {
-              thread_id: session.id,
-              checkpoint_ns: checkpointNamespace,
-              ...(currentCheckpointId ? { checkpoint_id: currentCheckpointId } : {}),
-            },
-          },
-        )
 
         for await (const event of eventStream) {
           const kind = event.event
@@ -1434,7 +1443,7 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
       } catch (innerErr: unknown) {
         const errName = innerErr instanceof Error ? innerErr.constructor.name : ''
         const errMsg = idleTimedOut
-          ? 'Model stream stalled without emitting text or tool results for 90 seconds.'
+          ? `Model stream stalled without emitting text or tool results for ${Math.trunc(runtime.streamIdleStallMs / 1000)} seconds.`
           : requiredToolKickoffTimedOut
             ? `The turn did not start the required workspace tool step within ${Math.trunc(REQUIRED_TOOL_KICKOFF_TIMEOUT_MS / 1000)} seconds.`
           : errorMessage(innerErr)
@@ -1539,24 +1548,6 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
         abortController.signal.removeEventListener('abort', onParentAbort)
       }
 
-      if (iterationSucceeded) {
-        try {
-          const state = await agent.getState({
-            configurable: {
-              thread_id: session.id,
-              checkpoint_ns: checkpointNamespace,
-              [LANGGRAPH_CHECKPOINTER_CONFIG_KEY]: checkpointSaver,
-            },
-          }) as { config?: { configurable?: { checkpoint_id?: unknown } } } | null
-          const latestCheckpointId = state?.config?.configurable?.checkpoint_id
-          if (typeof latestCheckpointId === 'string' && latestCheckpointId.trim()) {
-            currentCheckpointId = latestCheckpointId
-          }
-        } catch (checkpointErr) {
-          console.warn('[stream-agent-chat] Failed to refresh latest checkpoint state:', errorMessage(checkpointErr))
-        }
-      }
-
       if (reachedExecutionBoundary) break
 
       if (!shouldContinue
@@ -1592,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
@@ -1752,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
@@ -1765,6 +1771,7 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
         && hasToolCalls
         && textIsTrivial
         && streamedToolEvents.length > 0
+        && !skipToolSummaryForShortResponse
         && toolSummaryRetryCount < MAX_TOOL_SUMMARY_RETRIES
       ) {
         shouldContinue = 'tool_summary'
@@ -1808,7 +1815,9 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
         const promptMessage = new HumanMessage({ content: continuationPrompt })
         langchainMessages.push(promptMessage)
         continuationMessages.push(promptMessage)
-        pendingGraphMessages = continuationMessages
+        // Provide full conversation history since the agent has no checkpointer
+        // and each iteration starts with only the messages we explicitly pass.
+        pendingGraphMessages = [...langchainMessages]
         lastSegment = ''
       } else if (shouldContinue === 'transient') {
         // Exponential backoff before retrying transient errors; respect Retry-After if present
@@ -1896,7 +1905,7 @@ async function streamAgentChatCore(opts: StreamAgentChatOpts): Promise<StreamAge
   const totalTokens = totalInputTokens + totalOutputTokens
   if (totalTokens > 0) {
     const cost = estimateCost(session.model, totalInputTokens, totalOutputTokens)
-    const pluginDefinitionCosts = buildPluginDefinitionCosts(toolsForTurn, toolToPluginMap)
+    const pluginDefinitionCosts = buildPluginDefinitionCosts(tools, toolToPluginMap)
     const usageRecord: UsageRecord = {
       sessionId: session.id,
       messageIndex: history.length,

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

@@ -100,7 +100,7 @@ function looksLikeIncompleteDeliverableResponse(text: string): boolean {
 }
 
 const ARTIFACT_PATH_EXT_RE = /\.(?:md|txt|html?|json|csv|ya?ml|xml|pdf|png|jpe?g|webp|gif|svg|zip|ts|tsx|js|jsx|mjs|cjs|py|sql|sh)$/i
-const EXPLICIT_ARTIFACT_OUTPUT_RE = /\b(?:save|write|output|export)\b[^.!?\n]{0,80}\b(?:to|as|at|in)\b[^.!?\n]{0,60}(\/[^\s,'"]+\.(?:md|txt|html?|json|csv|ya?ml|xml|pdf|png|jpe?g|webp|gif|svg|zip|py|ts|tsx|js|jsx|mjs|cjs|sql|sh)|~\/[^\s,'"]+\.(?:md|txt|html?|json|csv|ya?ml|xml|pdf|png|jpe?g|webp|gif|svg|zip|py|ts|tsx|js|jsx|mjs|cjs|sql|sh)|\.\/[^\s,'"]+\.(?:md|txt|html?|json|csv|ya?ml|xml|pdf|png|jpe?g|webp|gif|svg|zip|py|ts|tsx|js|jsx|mjs|cjs|sql|sh)|[a-z0-9._/-]+\.(?:md|txt|html?|json|csv|ya?ml|xml|pdf|png|jpe?g|webp|gif|svg|zip|py|ts|tsx|js|jsx|mjs|cjs|sql|sh)\b)/i
+const EXPLICIT_ARTIFACT_OUTPUT_RE = /\b(?:save|write|output|export|create|generate)\b[^.!?\n]{0,80}\b(?:to|as|at|in)\b[^.!?\n]{0,60}(\/[^\s,'"]+\.(?:md|txt|html?|json|csv|ya?ml|xml|pdf|png|jpe?g|webp|gif|svg|zip|py|ts|tsx|js|jsx|mjs|cjs|sql|sh)|~\/[^\s,'"]+\.(?:md|txt|html?|json|csv|ya?ml|xml|pdf|png|jpe?g|webp|gif|svg|zip|py|ts|tsx|js|jsx|mjs|cjs|sql|sh)|\.\/[^\s,'"]+\.(?:md|txt|html?|json|csv|ya?ml|xml|pdf|png|jpe?g|webp|gif|svg|zip|py|ts|tsx|js|jsx|mjs|cjs|sql|sh)|[a-z0-9._/-]+\.(?:md|txt|html?|json|csv|ya?ml|xml|pdf|png|jpe?g|webp|gif|svg|zip|py|ts|tsx|js|jsx|mjs|cjs|sql|sh)\b)/i
 
 function hasExplicitFileOutputRequest(text: string): boolean {
   const normalized = text.toLowerCase()

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 }
+}