@swarmclawai/swarmclaw 0.6.4 → 0.6.6

package/src/lib/server/queue-followups.test.ts

@@ -0,0 +1,224 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import type { BoardTask } from '@/types'
+import { resolveTaskOriginConnectorFollowupTarget } from './queue'
+
+function makeTask(partial?: Partial<BoardTask> & { createdInSessionId?: string | null }): BoardTask {
+  const now = Date.now()
+  return {
+    id: 'task-1',
+    title: 'Test task',
+    description: 'desc',
+    status: 'queued',
+    agentId: 'agent-a',
+    createdAt: now,
+    updatedAt: now,
+    ...(partial || {}),
+  } as BoardTask
+}
+
+type SessionFixtureMap = Record<string, {
+  messages: Array<{
+    role: string
+    text?: string
+    source?: {
+      connectorId?: string
+      channelId?: string
+    }
+  }>
+}>
+
+describe('resolveTaskOriginConnectorFollowupTarget', () => {
+  it('uses connector source channel from origin session and normalizes WhatsApp numbers', () => {
+    const task = makeTask({ createdInSessionId: 'session-1' })
+    const sessions = {
+      'session-1': {
+        messages: [
+          { role: 'assistant', text: 'ok' },
+          {
+            role: 'user',
+            text: 'please update me',
+            source: {
+              connectorId: 'conn-wa',
+              channelId: '+44 7700 900123',
+            },
+          },
+        ],
+      },
+    }
+    const connectors = {
+      'conn-wa': {
+        id: 'conn-wa',
+        platform: 'whatsapp',
+        agentId: 'agent-a',
+        config: {},
+      },
+    }
+    const running = [
+      {
+        id: 'conn-wa',
+        platform: 'whatsapp',
+        agentId: 'agent-a',
+        supportsSend: true,
+        configuredTargets: [],
+        recentChannelId: '185200000000000@lid',
+      },
+    ]
+
+    const target = resolveTaskOriginConnectorFollowupTarget({
+      task,
+      sessions: sessions as SessionFixtureMap,
+      connectors,
+      running,
+    })
+
+    assert.deepEqual(target, {
+      connectorId: 'conn-wa',
+      channelId: '447700900123@s.whatsapp.net',
+    })
+  })
+
+  it('falls back to runtime recent channel when source channel is unavailable', () => {
+    const task = makeTask({ createdInSessionId: 'session-1' })
+    const sessions = {
+      'session-1': {
+        messages: [
+          {
+            role: 'user',
+            text: 'run this later',
+            source: {
+              connectorId: 'conn-telegram',
+            },
+          },
+        ],
+      },
+    }
+    const connectors = {
+      'conn-telegram': {
+        id: 'conn-telegram',
+        platform: 'telegram',
+        agentId: 'agent-a',
+        config: {},
+      },
+    }
+    const running = [
+      {
+        id: 'conn-telegram',
+        platform: 'telegram',
+        agentId: 'agent-a',
+        supportsSend: true,
+        configuredTargets: [],
+        recentChannelId: 'tg-chat-42',
+      },
+    ]
+
+    const target = resolveTaskOriginConnectorFollowupTarget({
+      task,
+      sessions: sessions as SessionFixtureMap,
+      connectors,
+      running,
+    })
+
+    assert.deepEqual(target, {
+      connectorId: 'conn-telegram',
+      channelId: 'tg-chat-42',
+    })
+  })
+
+  it('returns null when the source connector belongs to a different agent', () => {
+    const task = makeTask({ createdInSessionId: 'session-1' })
+    const sessions = {
+      'session-1': {
+        messages: [
+          {
+            role: 'user',
+            text: 'do it',
+            source: {
+              connectorId: 'conn-wa',
+              channelId: '+15551230000',
+            },
+          },
+        ],
+      },
+    }
+    const connectors = {
+      'conn-wa': {
+        id: 'conn-wa',
+        platform: 'whatsapp',
+        agentId: 'different-agent',
+        config: {},
+      },
+    }
+    const running = [
+      {
+        id: 'conn-wa',
+        platform: 'whatsapp',
+        agentId: 'different-agent',
+        supportsSend: true,
+        configuredTargets: [],
+        recentChannelId: null,
+      },
+    ]
+
+    const target = resolveTaskOriginConnectorFollowupTarget({
+      task,
+      sessions: sessions as SessionFixtureMap,
+      connectors,
+      running,
+    })
+
+    assert.equal(target, null)
+  })
+
+  it('allows delegated tasks to follow up via the delegating agent connector', () => {
+    const task = makeTask({
+      agentId: 'worker-agent',
+      delegatedByAgentId: 'delegator-agent',
+      createdInSessionId: 'session-1',
+    })
+    const sessions = {
+      'session-1': {
+        messages: [
+          {
+            role: 'user',
+            text: 'run and update me here',
+            source: {
+              connectorId: 'conn-wa',
+              channelId: '+44 7700 900123',
+            },
+          },
+        ],
+      },
+    }
+    const connectors = {
+      'conn-wa': {
+        id: 'conn-wa',
+        platform: 'whatsapp',
+        agentId: 'delegator-agent',
+        config: {},
+      },
+    }
+    const running = [
+      {
+        id: 'conn-wa',
+        platform: 'whatsapp',
+        agentId: 'delegator-agent',
+        supportsSend: true,
+        configuredTargets: [],
+        recentChannelId: null,
+      },
+    ]
+
+    const target = resolveTaskOriginConnectorFollowupTarget({
+      task,
+      sessions: sessions as SessionFixtureMap,
+      connectors,
+      running,
+    })
+
+    assert.deepEqual(target, {
+      connectorId: 'conn-wa',
+      channelId: '447700900123@s.whatsapp.net',
+    })
+  })
+})

package/src/lib/server/queue.ts

@@ -12,7 +12,7 @@ import { executeSessionChatTurn } from './chat-execution'
 import { extractTaskResult, formatResultBody } from './task-result'
 import { getCheckpointSaver } from './langgraph-checkpoint'
 import { isProtectedMainSession } from './main-session'
-import type { Agent, BoardTask, Message } from '@/types'
+import type { Agent, BoardTask, Connector, Message } from '@/types'
 
 // HMR-safe: pin processing flag to globalThis so hot reloads don't reset it
 const _queueState = ((globalThis as Record<string, unknown>).__swarmclaw_queue__ ??= { processing: false, pendingKick: false }) as { processing: boolean; pendingKick: boolean }
@@ -22,6 +22,10 @@ interface SessionMessageLike {
   text?: string
   time?: number
   kind?: 'chat' | 'heartbeat' | 'system' | 'context-clear'
+  source?: {
+    connectorId?: string
+    channelId?: string
+  }
   toolEvents?: Array<{ name?: string; output?: string }>
 }
 
@@ -39,6 +43,20 @@ interface ScheduleTaskMeta extends BoardTask {
   createdByAgentId?: string | null
 }
 
+interface RunningConnectorLike {
+  id: string
+  platform: string
+  agentId: string | null
+  supportsSend: boolean
+  configuredTargets: string[]
+  recentChannelId: string | null
+}
+
+interface ConnectorTaskFollowupTarget {
+  connectorId: string
+  channelId: string
+}
+
 function sameReasons(a?: string[] | null, b?: string[] | null): boolean {
   const av = Array.isArray(a) ? a : []
   const bv = Array.isArray(b) ? b : []
@@ -164,6 +182,135 @@ function maybeResolveUploadMediaPathFromUrl(url: string | undefined): string | u
   return fs.existsSync(fullPath) ? fullPath : undefined
 }
 
+const OUTPUT_FILE_BACKTICK_RE = /`([^`\n]+\.(?:txt|md|json|csv|pdf|png|jpe?g|webp|gif|svg|mp4|webm|mov|zip|tar|gz|log|yml|yaml|xml|html|css|js|ts|tsx|jsx|py|go|rs|java|swift|kt|sql))`/gi
+const OUTPUT_FILE_PATH_RE = /\b((?:\.{1,2}\/|~\/|\/)?[\w./-]+\.(?:txt|md|json|csv|pdf|png|jpe?g|webp|gif|svg|mp4|webm|mov|zip|tar|gz|log|yml|yaml|xml|html|css|js|ts|tsx|jsx|py|go|rs|java|swift|kt|sql))\b/gi
+const MAX_CONNECTOR_ATTACHMENT_BYTES = 25 * 1024 * 1024
+
+function extractLikelyOutputFiles(text: string): string[] {
+  const out: string[] = []
+  const seen = new Set<string>()
+  const push = (raw: string) => {
+    const value = raw.trim().replace(/^['"]|['"]$/g, '')
+    if (!value || /^https?:\/\//i.test(value)) return
+    if (value.startsWith('/api/uploads/')) return
+    const key = value.toLowerCase()
+    if (seen.has(key)) return
+    seen.add(key)
+    out.push(value)
+  }
+
+  for (const match of text.matchAll(OUTPUT_FILE_BACKTICK_RE)) {
+    push(match[1] || '')
+    if (out.length >= 8) return out
+  }
+  for (const match of text.matchAll(OUTPUT_FILE_PATH_RE)) {
+    push(match[1] || '')
+    if (out.length >= 8) return out
+  }
+
+  return out
+}
+
+function resolveExistingOutputFilePath(fileRef: string, cwd: string): string | null {
+  const ref = (fileRef || '').trim()
+  if (!ref) return null
+  if (ref.startsWith('/api/uploads/')) {
+    return maybeResolveUploadMediaPathFromUrl(ref) || null
+  }
+  const withoutFileScheme = ref.replace(/^file:\/\//i, '')
+  const candidates = path.isAbsolute(withoutFileScheme)
+    ? [withoutFileScheme]
+    : [
+        cwd ? path.resolve(cwd, withoutFileScheme) : '',
+        path.resolve(WORKSPACE_DIR, withoutFileScheme),
+      ].filter(Boolean)
+
+  for (const candidate of candidates) {
+    try {
+      const stat = fs.statSync(candidate)
+      if (stat.isFile()) return candidate
+    } catch {
+      // ignore missing candidate
+    }
+  }
+  return null
+}
+
+function isSendableAttachment(filePath: string): boolean {
+  try {
+    const stat = fs.statSync(filePath)
+    return stat.isFile() && stat.size <= MAX_CONNECTOR_ATTACHMENT_BYTES
+  } catch {
+    return false
+  }
+}
+
+export function resolveTaskOriginConnectorFollowupTarget(params: {
+  task: BoardTask
+  sessions: Record<string, SessionLike>
+  connectors: Record<string, Connector>
+  running: RunningConnectorLike[]
+}): ConnectorTaskFollowupTarget | null {
+  const { task, sessions, connectors, running } = params
+  const metaTask = task as ScheduleTaskMeta
+  const delegatedByAgentId = typeof metaTask.delegatedByAgentId === 'string'
+    ? metaTask.delegatedByAgentId.trim()
+    : ''
+  const sourceSessionId = typeof metaTask.createdInSessionId === 'string'
+    ? metaTask.createdInSessionId.trim()
+    : ''
+  if (!sourceSessionId) return null
+  const sourceSession = sessions[sourceSessionId]
+  if (!sourceSession || !Array.isArray(sourceSession.messages)) return null
+
+  const runningById = new Map<string, RunningConnectorLike>()
+  for (const entry of running) {
+    if (!entry?.id) continue
+    runningById.set(entry.id, entry)
+  }
+
+  for (let i = sourceSession.messages.length - 1; i >= 0; i--) {
+    const message = sourceSession.messages[i]
+    if (!message || message.role !== 'user') continue
+
+    const connectorId = typeof message.source?.connectorId === 'string'
+      ? message.source.connectorId.trim()
+      : ''
+    if (!connectorId) continue
+
+    const connector = connectors[connectorId]
+    if (!connector) continue
+    const ownerId = typeof connector.agentId === 'string' ? connector.agentId.trim() : ''
+    if (ownerId) {
+      const allowedOwners = new Set([task.agentId, delegatedByAgentId].filter(Boolean))
+      if (!allowedOwners.has(ownerId)) continue
+    }
+
+    const runtime = runningById.get(connectorId)
+    if (runtime && !runtime.supportsSend) continue
+
+    const sourceChannel = typeof message.source?.channelId === 'string'
+      ? message.source.channelId.trim()
+      : ''
+    const fallbackChannel = runtime?.recentChannelId
+      || runtime?.configuredTargets?.[0]
+      || connector.config?.outboundJid
+      || connector.config?.outboundTarget
+      || ''
+    const rawChannel = sourceChannel || fallbackChannel
+    if (!rawChannel) continue
+
+    return {
+      connectorId,
+      channelId: connector.platform === 'whatsapp'
+        ? normalizeWhatsappTarget(rawChannel)
+        : rawChannel,
+    }
+  }
+
+  return null
+}
+
 // Task result extraction now uses Zod-validated structured data
 // from ./task-result.ts (extractTaskResult, formatResultBody)
 
@@ -270,37 +417,67 @@ async function notifyConnectorTaskFollowups(params: {
   statusLabel: string
   summaryText: string
   imageUrl?: string
+  mediaPath?: string
+  mediaFileName?: string
 }) {
-  const { task, statusLabel, summaryText, imageUrl } = params
+  const { task, statusLabel, summaryText, imageUrl, mediaPath, mediaFileName } = params
 
   const connectors = loadConnectors()
   const running = (await import('./connectors/manager')).listRunningConnectors()
   const manager = await import('./connectors/manager')
+  const sessions = loadSessions()
 
-  const candidates = running.filter((entry) => {
-    if (!entry.supportsSend || !entry.id) return false
-    const connector = connectors[entry.id]
-    if (!connector) return false
-    if (connector.agentId !== task.agentId) return false
-    return isEnabledFlag(connector.config?.taskFollowups)
+  const candidateByKey = new Map<string, ConnectorTaskFollowupTarget>()
+  const addCandidate = (candidate: ConnectorTaskFollowupTarget | null | undefined) => {
+    if (!candidate?.connectorId || !candidate?.channelId) return
+    const key = `${candidate.connectorId}|${candidate.channelId}`
+    if (!candidateByKey.has(key)) candidateByKey.set(key, candidate)
+  }
+
+  const originTarget = resolveTaskOriginConnectorFollowupTarget({
+    task,
+    sessions: sessions as Record<string, SessionLike>,
+    connectors,
+    running: running as RunningConnectorLike[],
   })
-  if (!candidates.length) return
+  addCandidate(originTarget)
+  const preferredTargetKey = originTarget
+    ? `${originTarget.connectorId}|${originTarget.channelId}`
+    : ''
 
-  const summary = summaryText.trim().slice(0, 1400)
-  for (const candidate of candidates) {
-    const connector = connectors[candidate.id]
+  for (const entry of running) {
+    if (!entry.supportsSend || !entry.id) continue
+    const connector = connectors[entry.id]
     if (!connector) continue
-
-    const channelTargetRaw = candidate.recentChannelId
-      || candidate.configuredTargets[0]
+    if (connector.agentId !== task.agentId) continue
+    if (!isEnabledFlag(connector.config?.taskFollowups)) continue
+    const channelTargetRaw = entry.recentChannelId
+      || entry.configuredTargets[0]
       || connector.config?.outboundJid
       || connector.config?.outboundTarget
       || ''
     if (!channelTargetRaw) continue
+    addCandidate({
+      connectorId: entry.id,
+      channelId: connector.platform === 'whatsapp'
+        ? normalizeWhatsappTarget(channelTargetRaw)
+        : channelTargetRaw,
+    })
+  }
+  const targets = [...candidateByKey.values()].sort((a, b) => {
+    if (!preferredTargetKey) return 0
+    const aKey = `${a.connectorId}|${a.channelId}`
+    const bKey = `${b.connectorId}|${b.channelId}`
+    if (aKey === preferredTargetKey && bKey !== preferredTargetKey) return -1
+    if (bKey === preferredTargetKey && aKey !== preferredTargetKey) return 1
+    return 0
+  })
+  if (!targets.length) return
 
-    const channelId = connector.platform === 'whatsapp'
-      ? normalizeWhatsappTarget(channelTargetRaw)
-      : channelTargetRaw
+  const summary = summaryText.trim().slice(0, 1400)
+  for (const target of targets) {
+    const connector = connectors[target.connectorId]
+    if (!connector) continue
 
     const template = typeof connector.config?.taskFollowupTemplate === 'string'
       ? connector.config.taskFollowupTemplate.trim()
@@ -316,23 +493,29 @@ async function notifyConnectorTaskFollowups(params: {
           `Task ${statusLabel}: ${task.title}`,
           summary || 'No summary provided.',
         ].join('\n\n')
+    const targetKey = `${target.connectorId}|${target.channelId}`
+    const preferredChannelNote = !template && preferredTargetKey && targetKey === preferredTargetKey
+      ? '\n\n(Update sent in the same channel that requested this task.)'
+      : ''
+    const outboundMessage = `${message}${preferredChannelNote}`
 
-    const resolvedMediaPath = maybeResolveUploadMediaPathFromUrl(imageUrl)
+    const resolvedMediaPath = mediaPath || maybeResolveUploadMediaPathFromUrl(imageUrl)
     try {
       await manager.sendConnectorMessage({
-        connectorId: candidate.id,
-        channelId,
-        text: message,
+        connectorId: target.connectorId,
+        channelId: target.channelId,
+        text: outboundMessage,
         ...(resolvedMediaPath
           ? {
               mediaPath: resolvedMediaPath,
-              caption: message,
+              fileName: mediaFileName || path.basename(resolvedMediaPath),
+              caption: outboundMessage,
             }
           : {}),
       })
     } catch (err: unknown) {
       const errMsg = err instanceof Error ? err.message : String(err)
-      console.warn(`[queue] Failed task follow-up send on connector ${candidate.id}: ${errMsg}`)
+      console.warn(`[queue] Failed task follow-up send on connector ${target.connectorId}: ${errMsg}`)
     }
   }
 }
@@ -358,10 +541,16 @@ function notifyAgentThreadTaskResult(task: BoardTask): void {
     { sinceTime: typeof task.startedAt === 'number' ? task.startedAt : null },
   )
   const resultBody = formatResultBody(taskResult)
+  const outputFileRefs = Array.isArray(task.outputFiles) && task.outputFiles.length > 0
+    ? task.outputFiles
+    : extractLikelyOutputFiles(resultBody)
 
   const statusLabel = task.status === 'completed' ? 'completed' : 'failed'
   const taskLink = `[${task.title}](#task:${task.id})`
   const firstImage = taskResult.artifacts.find((a) => a.type === 'image')
+  const firstArtifactMediaPath = taskResult.artifacts
+    .map((artifact) => maybeResolveUploadMediaPathFromUrl(artifact.url))
+    .find((candidate): candidate is string => Boolean(candidate))
   const now = Date.now()
   let changed = false
 
@@ -377,6 +566,11 @@ function notifyAgentThreadTaskResult(task: BoardTask): void {
 
   // Get working directory from execution session
   const execCwd = runSession?.cwd || ''
+  const existingOutputPaths = outputFileRefs
+    .map((fileRef) => resolveExistingOutputFilePath(fileRef, execCwd))
+    .filter((candidate): candidate is string => Boolean(candidate))
+  const firstLocalOutputPath = existingOutputPaths.find((candidate) => isSendableAttachment(candidate))
+  const followupMediaPath = firstArtifactMediaPath || firstLocalOutputPath || undefined
 
   const buildMsg = (text: string): Message => {
     const msg: Message = { role: 'assistant', text, time: now, kind: 'system' }
@@ -387,6 +581,10 @@ function notifyAgentThreadTaskResult(task: BoardTask): void {
   const buildResultBlock = (prefix: string): string => {
     const parts = [prefix]
     if (execCwd) parts.push(`Working directory: \`${execCwd}\``)
+    if (outputFileRefs.length > 0) {
+      parts.push(`Output files:\n${outputFileRefs.slice(0, 8).map((fileRef) => `- \`${fileRef}\``).join('\n')}`)
+    }
+    if (task.completionReportPath) parts.push(`Task report: \`${task.completionReportPath}\``)
     if (resumeLines.length > 0) parts.push(resumeLines.join(' | '))
     parts.push(resultBody || 'No summary.')
     return parts.join('\n\n')
@@ -449,6 +647,8 @@ function notifyAgentThreadTaskResult(task: BoardTask): void {
     statusLabel,
     summaryText: resultBody || '',
     imageUrl: firstImage?.url,
+    mediaPath: followupMediaPath,
+    mediaFileName: followupMediaPath ? path.basename(followupMediaPath) : undefined,
   })
 }
 
@@ -812,6 +1012,8 @@ export async function processNext() {
           )
           const enrichedResult = formatResultBody(taskResult)
           t2[taskId].result = enrichedResult.slice(0, 4000) || null
+          t2[taskId].artifacts = taskResult.artifacts.slice(0, 24)
+          t2[taskId].outputFiles = extractLikelyOutputFiles(enrichedResult).slice(0, 24)
           t2[taskId].updatedAt = Date.now()
           const report = ensureTaskCompletionReport(t2[taskId])
           if (report?.relativePath) t2[taskId].completionReportPath = report.relativePath

package/src/lib/server/scheduler.ts

@@ -146,7 +146,10 @@ async function tick() {
       existingTask.title = `[Sched] ${schedule.name} (run #${schedule.runNumber})`
       existingTask.result = null
       existingTask.error = null
+      existingTask.outputFiles = []
+      existingTask.artifacts = []
       existingTask.sessionId = null
+      existingTask.completionReportPath = null
       existingTask.updatedAt = now
       existingTask.queuedAt = null
       existingTask.startedAt = null

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

@@ -13,7 +13,7 @@ export function buildChatroomTools(bctx: ToolBuildContext): StructuredToolInterf
   if (hasTool('manage_chatrooms')) {
     tools.push(
       tool(
-        async ({ action, chatroomId, name, description, agentIds, agentId, message }) => {
+        async ({ action, chatroomId, name, description, agentIds, agentId, message, chatMode, autoAddress }) => {
           try {
             const chatrooms = loadChatrooms() as Record<string, Chatroom>
 
@@ -31,13 +31,20 @@ export function buildChatroomTools(bctx: ToolBuildContext): StructuredToolInterf
             if (action === 'create_chatroom') {
               const id = genId()
               const agents = loadAgents()
-              const validAgentIds = (agentIds || []).filter((aid: string) => agents[aid])
+              const requestedAgentIds = agentIds || []
+              const invalidAgentIds = requestedAgentIds.filter((aid: string) => !agents[aid])
+              if (invalidAgentIds.length > 0) {
+                return `Error: unknown agent IDs: ${invalidAgentIds.join(', ')}`
+              }
+              const validAgentIds = requestedAgentIds
               const chatroom: Chatroom = {
                 id,
                 name: name || 'New Chatroom',
                 description: description || '',
                 agentIds: validAgentIds,
                 messages: [],
+                chatMode: chatMode === 'parallel' ? 'parallel' : 'sequential',
+                autoAddress: Boolean(autoAddress),
                 createdAt: Date.now(),
                 updatedAt: Date.now(),
               }
@@ -124,6 +131,8 @@ export function buildChatroomTools(bctx: ToolBuildContext): StructuredToolInterf
             name: z.string().optional().describe('Chatroom name (for create_chatroom)'),
             description: z.string().optional().describe('Chatroom description (for create_chatroom)'),
             agentIds: z.array(z.string()).optional().describe('Initial agent IDs (for create_chatroom)'),
+            chatMode: z.enum(['sequential', 'parallel']).optional().describe('Optional orchestration mode for create_chatroom'),
+            autoAddress: z.boolean().optional().describe('Whether to auto-address all members when no @mention is present'),
             agentId: z.string().optional().describe('Agent ID (for add_agent/remove_agent)'),
             message: z.string().optional().describe('Message text (for send_message)'),
           }),

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

@@ -28,7 +28,7 @@ export function buildContextTools(bctx: ToolBuildContext): StructuredToolInterfa
         },
         {
           name: 'context_status',
-          description: 'Check current context window usage for this session. Returns estimated tokens used, provider context limit, percentage used, and compaction strategy recommendation.',
+          description: 'Check how much of my context window I\'ve used. Returns my token usage, the model\'s limit, percentage used, and whether I should compact.',
           schema: z.object({}),
         },
       ),
@@ -108,7 +108,7 @@ export function buildContextTools(bctx: ToolBuildContext): StructuredToolInterfa
         },
         {
           name: 'context_summarize',
-          description: 'Summarize and compact the conversation history to free context window space. Old messages are consolidated to memory (preserving decisions, key facts, results) and replaced with a summary. Use context_status first to check if compaction is needed.',
+          description: 'Compact my conversation history to free up context space. I\'ll save important decisions, facts, and results to memory, then replace older messages with a summary. I should check context_status first to see if this is needed.',
           schema: z.object({
             keepLastN: z.number().optional().describe('Number of recent messages to keep (default 10, min 2).'),
           }),

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

@@ -21,6 +21,7 @@ import { buildSubagentTools } from './subagent'
 import { buildCanvasTools } from './canvas'
 import { buildHttpTools } from './http'
 import { buildGitTools } from './git'
+import { buildWalletTools } from './wallet'
 
 export type { ToolContext, SessionToolsResult }
 export { sweepOrphanedBrowsers, cleanupSessionBrowser, getActiveBrowserCount, hasActiveBrowser }
@@ -34,7 +35,9 @@ export async function buildSessionTools(cwd: string, enabledTools: string[], ctx
   const cliProcessTimeoutMs = runtime.cliProcessTimeoutMs
   const appSettings = loadSettings()
   const toolPolicy = resolveSessionToolPolicy(enabledTools, appSettings)
-  const activeTools = toolPolicy.enabledTools
+  const activeTools = toolPolicy.enabledTools.includes('shell') && !toolPolicy.enabledTools.includes('process')
+    ? [...toolPolicy.enabledTools, 'process']
+    : toolPolicy.enabledTools
   const hasTool = (toolName: string) => activeTools.includes(toolName)
 
   if (toolPolicy.blockedTools.length > 0) {
@@ -107,6 +110,7 @@ export async function buildSessionTools(cwd: string, enabledTools: string[], ctx
     ...buildCanvasTools(bctx),
     ...buildHttpTools(bctx),
     ...buildGitTools(bctx),
+    ...buildWalletTools(bctx),
   )
 
   // ---------------------------------------------------------------------------
@@ -158,7 +162,7 @@ export async function buildSessionTools(cwd: string, enabledTools: string[], ctx
       },
       {
         name: 'request_tool_access',
-        description: 'Request access to a tool that is currently disabled. The user will be prompted to grant access, and a follow-up "Continue" message will be sent automatically once granted. End your current response after calling this — do NOT tell the user to "let you know" or ask them to confirm; the continuation is automatic.',
+        description: 'Ask the user for access to a tool I don\'t currently have. They\'ll get a prompt to grant it, and once they do, I\'ll automatically continue where I left off. I should end my current response after calling this — no need to ask the user to confirm, it happens on its own.',
         schema: z.object({
           toolId: z.string().describe('The tool ID to request access for (e.g. manage_tasks, shell, claude_code)'),
           reason: z.string().describe('Brief explanation of why you need this tool'),