@swarmclawai/swarmclaw 0.7.2 → 0.7.4

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

@@ -4,7 +4,9 @@ import { active, loadSessions } from './storage'
 import { executeSessionChatTurn, type ExecuteChatTurnResult } from './chat-execution'
 import { loadRuntimeSettings } from './runtime-settings'
 import { log } from './logger'
-import { handleMainLoopRunResult, type MainLoopFollowupRequest } from './main-agent-loop'
+import { isInternalHeartbeatRun } from './heartbeat-source'
+import { cleanupSessionBrowser } from './session-tools/web'
+import { cancelDelegationJobsForParentSession } from './delegation-jobs'
 
 export type SessionRunStatus = 'queued' | 'running' | 'completed' | 'failed' | 'cancelled'
 export type SessionQueueMode = 'followup' | 'steer' | 'collect'
@@ -122,6 +124,23 @@ function emitRunMeta(entry: QueueEntry, status: SessionRunStatus, extra?: Record
   })
 }
 
+function markRunningEntryCancelled(entry: QueueEntry, reason: string) {
+  if (entry.run.status === 'cancelled') return
+  entry.run.status = 'cancelled'
+  entry.run.endedAt = now()
+  entry.run.error = reason
+  emitRunMeta(entry, 'cancelled', { reason })
+}
+
+function abortSessionRuntime(entry: QueueEntry, reason: string) {
+  markRunningEntryCancelled(entry, reason)
+  entry.signalController.abort()
+  try { active.get(entry.run.sessionId)?.kill?.() } catch { /* noop */ }
+  active.delete(entry.run.sessionId)
+  try { cleanupSessionBrowser(entry.run.sessionId) } catch { /* noop */ }
+  try { cancelDelegationJobsForParentSession(entry.run.sessionId, reason) } catch { /* noop */ }
+}
+
 function executionKeyForSession(sessionId: string): string {
   return `session:${sessionId}`
 }
@@ -170,7 +189,7 @@ export function cancelAllHeartbeatRuns(reason = 'Heartbeat disabled globally'):
     if (!queue.length) continue
     const keep: QueueEntry[] = []
     for (const entry of queue) {
-      const isHeartbeat = entry.run.internal === true && entry.run.source === 'heartbeat'
+      const isHeartbeat = isInternalHeartbeatRun(entry.run.internal, entry.run.source)
       if (!isHeartbeat) {
         keep.push(entry)
         continue
@@ -187,45 +206,15 @@ export function cancelAllHeartbeatRuns(reason = 'Heartbeat disabled globally'):
   }
 
   for (const entry of state.runningByExecution.values()) {
-    const isHeartbeat = entry.run.internal === true && entry.run.source === 'heartbeat'
+    const isHeartbeat = isInternalHeartbeatRun(entry.run.internal, entry.run.source)
     if (!isHeartbeat) continue
     abortedRunning += 1
-    entry.signalController.abort()
-    try { active.get(entry.run.sessionId)?.kill?.() } catch { /* noop */ }
+    abortSessionRuntime(entry, reason)
   }
 
   return { cancelledQueued, abortedRunning }
 }
 
-function scheduleMainLoopFollowup(sessionId: string, followup: MainLoopFollowupRequest) {
-  const delayMs = Math.max(0, Math.trunc(followup.delayMs || 0))
-  setTimeout(() => {
-    try {
-      const sessions = loadSessions()
-      const session = sessions[sessionId]
-      if (!session || !isMainMissionSession(session)) return
-      enqueueSessionRun({
-        sessionId,
-        message: followup.message,
-        internal: true,
-        source: 'main-loop-followup',
-        mode: 'collect',
-        dedupeKey: followup.dedupeKey,
-      })
-    } catch (err: any) {
-      log.warn('session-run', `Failed to enqueue main-loop followup for ${sessionId}`, err?.message || String(err))
-    }
-  }, delayMs)
-}
-
-export function isMainMissionSession(session: Record<string, unknown>): boolean {
-  const id = typeof session.id === 'string' ? session.id.trim() : ''
-  const sessionType = typeof session.sessionType === 'string' ? session.sessionType : ''
-  if (id.startsWith('agent-thread-')) return true
-  if (sessionType === 'orchestrated') return true
-  return false
-}
-
 async function drainExecution(executionKey: string): Promise<void> {
   if (state.runningByExecution.has(executionKey)) return
   const q = queueForExecution(executionKey)
@@ -269,49 +258,25 @@ async function drainExecution(executionKey: string): Promise<void> {
     })
 
     const failed = !!result.error
-    let followup: MainLoopFollowupRequest | null = null
-    try {
-      followup = handleMainLoopRunResult({
-        sessionId: next.run.sessionId,
-        message: next.message,
-        internal: next.run.internal,
-        source: next.run.source,
-        resultText: result.text,
-        error: result.error,
-        toolEvents: result.toolEvents,
-        inputTokens: result.inputTokens,
-        outputTokens: result.outputTokens,
-        estimatedCost: result.estimatedCost,
-      })
-    } catch (mainLoopErr: any) {
-      log.warn('session-run', `Main-loop update failed for ${next.run.id}`, mainLoopErr?.message || String(mainLoopErr))
-    }
-
-    next.run.status = failed ? 'failed' : 'completed'
-    next.run.endedAt = now()
-    next.run.error = result.error
+    const aborted = next.signalController.signal.aborted
+    next.run.status = aborted ? 'cancelled' : (failed ? 'failed' : 'completed')
+    next.run.endedAt = next.run.endedAt || now()
+    next.run.error = aborted ? (next.run.error || 'Cancelled') : result.error
     next.run.resultPreview = result.text?.slice(0, 280)
     emitRunMeta(next, next.run.status, {
       persisted: result.persisted,
       hasText: !!result.text,
-      error: result.error || null,
+      error: next.run.error || null,
     })
     log.info('session-run', `Run finished ${next.run.id}`, {
       sessionId: next.run.sessionId,
       status: next.run.status,
       persisted: result.persisted,
       hasText: !!result.text,
-      error: result.error || null,
+      error: next.run.error || null,
       durationMs: (next.run.endedAt || now()) - (next.run.startedAt || now()),
     })
     next.resolve(result)
-    if (!failed && followup) {
-      scheduleMainLoopFollowup(next.run.sessionId, followup)
-      log.info('session-run', `Queued main-loop followup after ${next.run.id}`, {
-        sessionId: next.run.sessionId,
-        delayMs: followup.delayMs,
-      })
-    }
   } catch (err: any) {
     const aborted = next.signalController.signal.aborted
     next.run.status = aborted ? 'cancelled' : 'failed'
@@ -324,19 +289,6 @@ async function drainExecution(executionKey: string): Promise<void> {
       error: next.run.error,
       durationMs: (next.run.endedAt || now()) - (next.run.startedAt || now()),
     })
-    try {
-      handleMainLoopRunResult({
-        sessionId: next.run.sessionId,
-        message: next.message,
-        internal: next.run.internal,
-        source: next.run.source,
-        resultText: '',
-        error: next.run.error,
-        toolEvents: [],
-      })
-    } catch {
-      // Main-loop bookkeeping failures should not affect queue execution.
-    }
     next.reject(err instanceof Error ? err : new Error(next.run.error))
   } finally {
     if (runtimeTimer) clearTimeout(runtimeTimer)
@@ -528,7 +480,9 @@ export function getSessionRunState(sessionId: string): {
   const running = state.runningByExecution.get(executionKey)
   const queued = queueForExecution(executionKey).filter((entry) => entry.run.sessionId === sessionId).length
   return {
-    runningRunId: running?.run.sessionId === sessionId ? running.run.id : undefined,
+    runningRunId: (running?.run.sessionId === sessionId && running.run.status === 'running')
+      ? running.run.id
+      : undefined,
     queueLength: queued,
   }
 }
@@ -562,8 +516,7 @@ export function cancelSessionRuns(sessionId: string, reason = 'Cancelled'): { ca
   let cancelledRunning = false
   if (running && running.run.sessionId === sessionId) {
     cancelledRunning = true
-    running.signalController.abort()
-    try { active.get(sessionId)?.kill?.() } catch { /* noop */ }
+    abortSessionRuntime(running, reason)
   }
   const cancelledQueued = cancelPendingForSession(sessionId, reason)
   return { cancelledQueued, cancelledRunning }

package/src/lib/server/session-tools/autonomy-tools.test.ts

@@ -0,0 +1,128 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import path from 'node:path'
+import { describe, it } from 'node:test'
+
+const thisFile = new URL(import.meta.url).pathname
+const toolsDir = path.dirname(thisFile)
+const serverDir = path.resolve(toolsDir, '..')
+
+function readToolSource(fileName: string): string {
+  return fs.readFileSync(path.join(toolsDir, fileName), 'utf-8')
+}
+
+function readServerSource(fileName: string): string {
+  return fs.readFileSync(path.join(serverDir, fileName), 'utf-8')
+}
+
+describe('browser workflow surface', () => {
+  it('advertises the higher-level browser actions in web.ts', () => {
+    const src = readToolSource('web.ts')
+    for (const action of ['read_page', 'extract_links', 'extract_form_fields', 'extract_table', 'fill_form', 'submit_form', 'scroll_until', 'download_file', 'complete_web_task']) {
+      assert.equal(src.includes(`'${action}'`), true, `web.ts should expose ${action}`)
+    }
+  })
+
+  it('supports the shorthand form-map path for fill_form', () => {
+    const src = readToolSource('web.ts')
+    assert.equal(src.includes('params.form'), true)
+    assert.equal(src.includes('fields is required for fill_form.'), true)
+  })
+
+  it('flags pages that require human-provided input', () => {
+    const src = readToolSource('web.ts')
+    assert.equal(src.includes("type: 'human_input_required'"), true)
+    assert.equal(src.includes('Ask the human instead of guessing'), true)
+  })
+})
+
+describe('durable wait surface', () => {
+  it('advertises the durable wait actions in monitor.ts', () => {
+    const src = readToolSource('monitor.ts')
+    for (const action of ['wait_until', 'wait_for_http', 'wait_for_file', 'wait_for_task', 'wait_for_webhook', 'wait_for_page_change']) {
+      assert.equal(src.includes(`'${action}'`), true, `monitor.ts should expose ${action}`)
+    }
+    assert.equal(src.includes('createDurableWatch'), true)
+  })
+
+  it('routes schedule_wake through durable watch storage', () => {
+    const src = readToolSource('schedule.ts')
+    assert.equal(src.includes('createWatchJob'), true)
+    assert.equal(src.includes("type: 'time'"), true)
+  })
+})
+
+describe('sandbox surface', () => {
+  it('advertises a Deno-only sandbox and steers simple APIs to http_request', () => {
+    const src = readToolSource('sandbox.ts')
+    assert.equal(src.includes("enum: ['javascript', 'typescript']"), true)
+    assert.equal(src.includes('http_request'), true)
+    assert.equal(src.includes('plugin_creator'), true)
+    assert.equal(src.includes('manage_schedules'), true)
+    assert.equal(src.includes('openclaw_sandbox'), false)
+  })
+})
+
+describe('delegation job handles', () => {
+  it('exposes subagent control actions', () => {
+    const src = readToolSource('subagent.ts')
+    for (const action of ['status', 'list', 'wait', 'cancel']) {
+      assert.equal(src.includes(`action === '${action}'`), true, `subagent.ts should handle ${action}`)
+    }
+    assert.equal(src.includes('createDelegationJob'), true)
+  })
+
+  it('builds delegate context from the invoking session and uses job records', () => {
+    const src = readToolSource('delegate.ts')
+    assert.equal(src.includes('buildDelegateContextFromSessionish'), true)
+    assert.equal(src.includes('createDelegationJob'), true)
+    assert.equal(src.includes('waitForDelegateJob'), true)
+  })
+
+  it('scheduler and daemon recover the durable autonomy jobs', () => {
+    const schedulerSrc = readServerSource('scheduler.ts')
+    const daemonSrc = readServerSource('daemon-state.ts')
+    assert.equal(schedulerSrc.includes('processDueWatchJobs'), true)
+    assert.equal(daemonSrc.includes('recoverStaleDelegationJobs'), true)
+  })
+})
+
+describe('primitive plugin surfaces', () => {
+  it('advertises mailbox and human-loop actions', () => {
+    const mailboxSrc = readToolSource('mailbox.ts')
+    const humanSrc = readToolSource('human-loop.ts')
+    for (const action of ['list_messages', 'list_threads', 'search_messages', 'read_message', 'download_attachment', 'reply', 'wait_for_email']) {
+      assert.equal(mailboxSrc.includes(`'${action}'`), true, `mailbox.ts should expose ${action}`)
+    }
+    for (const action of ['request_input', 'request_approval', 'wait_for_reply', 'wait_for_approval', 'list_mailbox', 'ack_mailbox', 'status']) {
+      assert.equal(humanSrc.includes(`'${action}'`), true, `human-loop.ts should expose ${action}`)
+    }
+  })
+
+  it('advertises document, extract, table, and crawl actions', () => {
+    const documentSrc = readToolSource('document.ts')
+    const extractSrc = readToolSource('extract.ts')
+    const tableSrc = readToolSource('table.ts')
+    const crawlSrc = readToolSource('crawl.ts')
+
+    for (const action of ['read', 'metadata', 'ocr', 'extract_tables', 'store', 'list', 'search', 'get', 'delete']) {
+      assert.equal(documentSrc.includes(`'${action}'`), true, `document.ts should expose ${action}`)
+    }
+    for (const action of ['extract_structured', 'summarize', 'status']) {
+      assert.equal(extractSrc.includes(`'${action}'`), true, `extract.ts should expose ${action}`)
+    }
+    for (const action of ['read', 'load_csv', 'load_xlsx', 'summarize', 'filter', 'sort', 'group', 'pivot', 'dedupe', 'join', 'write']) {
+      assert.equal(tableSrc.includes(`'${action}'`), true, `table.ts should expose ${action}`)
+    }
+    for (const action of ['crawl_site', 'follow_pagination', 'extract_sitemap', 'dedupe_pages', 'batch_extract']) {
+      assert.equal(crawlSrc.includes(`'${action}'`), true, `crawl.ts should expose ${action}`)
+    }
+  })
+
+  it('registers the primitive plugins in builtin-plugins.ts', () => {
+    const src = readServerSource('builtin-plugins.ts')
+    for (const moduleName of ['mailbox', 'human-loop', 'document', 'extract', 'table', 'crawl']) {
+      assert.equal(src.includes(`session-tools/${moduleName}`), true, `builtin-plugins.ts should import ${moduleName}`)
+    }
+  })
+})

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

@@ -3,7 +3,6 @@ import { tool, type StructuredToolInterface } from '@langchain/core/tools'
 import type { Plugin, PluginHooks } from '@/types'
 import { getPluginManager } from '../plugins'
 import { normalizeToolInputArgs } from './normalize-tool-args'
-import { loadSettings } from '../storage'
 import type { ToolBuildContext } from './context'
 
 type CalendarProvider = 'google' | 'outlook'
@@ -18,8 +17,7 @@ interface CalendarConfig {
 }
 
 function getConfig(): CalendarConfig {
-  const settings = loadSettings()
-  const ps = (settings.pluginSettings as Record<string, Record<string, unknown>> | undefined)?.calendar ?? {}
+  const ps = getPluginManager().getPluginSettings('calendar')
   return {
     provider: (ps.provider as CalendarProvider) || 'google',
     accessToken: (ps.accessToken as string) || '',
@@ -49,15 +47,7 @@ async function refreshGoogleToken(cfg: CalendarConfig): Promise<string | null> {
     const data = await res.json()
     const newToken = data?.access_token as string | undefined
     if (newToken) {
-      // Persist the refreshed token
-      const settings = loadSettings()
-      const pluginSettings = (settings.pluginSettings as Record<string, Record<string, unknown>> | undefined) ?? {}
-      const calSettings = pluginSettings.calendar ?? {}
-      calSettings.accessToken = newToken
-      pluginSettings.calendar = calSettings
-      settings.pluginSettings = pluginSettings
-      const { saveSettings } = await import('../storage')
-      saveSettings(settings)
+      getPluginManager().setPluginSettings('calendar', { ...cfg, accessToken: newToken })
     }
     return newToken || null
   } catch {

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

@@ -60,8 +60,6 @@ function isAutonomousSystemTurn(userText: string): boolean {
   if (!userText) return false
   const text = userText.toUpperCase()
   return text.includes('AGENT_HEARTBEAT_WAKE')
-    || text.includes('SWARM_MAIN_MISSION_TICK')
-    || text.includes('SWARM_MAIN_AUTO_FOLLOWUP')
     || text.includes('SWARM_HEARTBEAT_CHECK')
 }
 
@@ -247,6 +245,9 @@ interface ConnectorActionInput {
   platform?: string
   to?: string
   message?: string
+  messageId?: string
+  targetMessage?: 'last_inbound' | 'last_outbound'
+  emoji?: string
   voiceText?: string
   voiceId?: string
   imageUrl?: string
@@ -255,9 +256,12 @@ interface ConnectorActionInput {
   mimeType?: string
   fileName?: string
   caption?: string
+  replyToMessageId?: string
+  threadId?: string
   delaySec?: number
   followUpMessage?: string
   followUpDelaySec?: number
+  dedupeKey?: string
   approved?: boolean
   ptt?: boolean
 }
@@ -284,13 +288,25 @@ async function executeConnectorAction(input: ConnectorActionInput, bctx: Connect
     mimeType,
     fileName,
     caption,
+    messageId,
+    targetMessage,
+    emoji,
+    replyToMessageId,
+    threadId,
+    dedupeKey,
     approved,
     ptt,
   } = normalized as ConnectorActionInput
 
   try {
     const actionName = String(action)
-    const { listRunningConnectors, sendConnectorMessage, getConnectorRecentChannelId } = await import('../connectors/manager')
+    const {
+      listRunningConnectors,
+      sendConnectorMessage,
+      getConnectorRecentChannelId,
+      scheduleConnectorFollowUp,
+      performConnectorMessageAction,
+    } = await import('../connectors/manager')
     const running = listRunningConnectors(platform || undefined)
 
     if (actionName === 'list_running' || actionName === 'list_targets') {
@@ -342,6 +358,9 @@ async function executeConnectorAction(input: ConnectorActionInput, bctx: Connect
       return { selected, connector }
     }
 
+    const currentSession = bctx.resolveCurrentSession?.()
+    const sessionId = bctx.ctx?.sessionId || currentSession?.id || undefined
+
     if (actionName === 'send' || actionName === 'send_voice_note' || actionName === 'schedule_followup') {
       const settings = loadSettings()
       if (settings.safetyRequireApprovalForOutbound === true && approved !== true) {
@@ -363,9 +382,7 @@ async function executeConnectorAction(input: ConnectorActionInput, bctx: Connect
       let channelId = target.channelId
       if (connector.platform === 'whatsapp') channelId = normalizeWhatsAppTarget(channelId)
 
-      const currentSession = bctx.resolveCurrentSession?.()
       const latestUserTurn = parseLatestUserTurn(currentSession)
-      const sessionId = bctx.ctx?.sessionId || currentSession?.id || 'unknown-session'
       const turnKey = buildConnectorActionKey([sessionId, latestUserTurn.time || 'no-user-turn'])
       const multiOutboundAllowed = userExplicitlyWantsMultipleOutbound(latestUserTurn.text)
       // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -392,6 +409,9 @@ async function executeConnectorAction(input: ConnectorActionInput, bctx: Connect
         const sent = await sendConnectorMessage({
           connectorId: selected.id, channelId, text: '', mediaPath: voicePath, mimeType: 'audio/mpeg',
           fileName: fileName?.trim() || 'voicenote.mp3', caption: caption?.trim() || undefined, ptt: ptt ?? true,
+          sessionId,
+          replyToMessageId: replyToMessageId?.trim() || undefined,
+          threadId: threadId?.trim() || undefined,
         })
         const result = JSON.stringify({ status: 'voice_sent', connectorId: sent.connectorId, platform: sent.platform, to: sent.channelId, voiceFile: voicePath })
         connectorTurnSendBudget.set(turnKey, { count: (existingBudget?.count || 0) + 1, at: now, lastResult: result })
@@ -405,11 +425,54 @@ async function executeConnectorAction(input: ConnectorActionInput, bctx: Connect
         return 'Error: message or media required.'
       }
 
+      if (actionName === 'schedule_followup') {
+        const followupText = (normalized.followUpMessage as string | undefined)?.trim() || message?.trim() || ''
+        if (!followupText && !media.mediaPath && !media.imageUrl && !media.fileUrl) {
+          return 'Error: follow-up message or media required.'
+        }
+        const followupDelay = (() => {
+          const direct = Number(normalized.followUpDelaySec)
+          if (Number.isFinite(direct) && direct >= 0) return direct
+          const fallback = Number(normalized.delaySec)
+          if (Number.isFinite(fallback) && fallback >= 0) return fallback
+          return 300
+        })()
+        const scheduled = scheduleConnectorFollowUp({
+          connectorId: selected.id,
+          channelId,
+          text: followupText,
+          sessionId,
+          delaySec: followupDelay,
+          dedupeKey: dedupeKey?.trim() || undefined,
+          imageUrl: media.imageUrl,
+          fileUrl: media.fileUrl,
+          mediaPath: media.mediaPath,
+          mimeType: mimeType?.trim() || undefined,
+          fileName: fileName?.trim() || undefined,
+          caption: caption?.trim() || undefined,
+          replyToMessageId: replyToMessageId?.trim() || undefined,
+          threadId: threadId?.trim() || undefined,
+          ptt: ptt ?? undefined,
+        })
+        return JSON.stringify({
+          status: 'scheduled',
+          connectorId: selected.id,
+          platform: selected.platform,
+          to: channelId,
+          followUpId: scheduled.followUpId,
+          sendAt: scheduled.sendAt,
+        })
+      }
+
       const sent = await sendConnectorMessage({
         connectorId: selected.id, channelId, text: message?.trim() || '',
+        sessionId,
         imageUrl: media.imageUrl, fileUrl: media.fileUrl, mediaPath: media.mediaPath,
         mimeType: mimeType?.trim() || undefined, fileName: fileName?.trim() || undefined,
-        caption: caption?.trim() || undefined, ptt: ptt ?? undefined,
+        caption: caption?.trim() || undefined,
+        replyToMessageId: replyToMessageId?.trim() || undefined,
+        threadId: threadId?.trim() || undefined,
+        ptt: ptt ?? undefined,
       })
 
       const result = JSON.stringify({ status: 'sent', connectorId: sent.connectorId, platform: sent.platform, to: sent.channelId, messageId: sent.messageId || null })
@@ -417,6 +480,35 @@ async function executeConnectorAction(input: ConnectorActionInput, bctx: Connect
       return result
     }
 
+    if (actionName === 'react' || actionName === 'edit' || actionName === 'delete' || actionName === 'pin') {
+      const resolved = resolveSelectedConnector()
+      if ('error' in resolved) return resolved.error
+      const { selected } = resolved
+      const target = pickChannelTarget({
+        connector: resolved.connector,
+        to,
+        recentChannelId: getConnectorRecentChannelId(selected.id),
+      })
+      if (target.error) return target.error
+      const result = await performConnectorMessageAction({
+        connectorId: selected.id,
+        channelId: selected.platform === 'whatsapp' ? normalizeWhatsAppTarget(target.channelId) : target.channelId,
+        action: actionName,
+        messageId: messageId?.trim() || undefined,
+        emoji: emoji?.trim() || undefined,
+        text: message?.trim() || undefined,
+        sessionId,
+        targetMessage,
+      })
+      return JSON.stringify({
+        status: actionName,
+        connectorId: result.connectorId,
+        platform: result.platform,
+        to: result.channelId,
+        messageId: result.messageId || null,
+      })
+    }
+
     return 'Unknown action.'
   } catch (err: unknown) {
     return `Error: ${err instanceof Error ? err.message : String(err)}`
@@ -440,11 +532,20 @@ const ConnectorPlugin: Plugin = {
       parameters: {
         type: 'object',
         properties: {
-          action: { type: 'string', enum: ['list_running', 'start', 'stop', 'send', 'send_voice_note'] },
+          action: { type: 'string', enum: ['list_running', 'start', 'stop', 'send', 'send_voice_note', 'schedule_followup', 'react', 'edit', 'delete', 'pin'] },
           connectorId: { type: 'string' },
           platform: { type: 'string' },
           to: { type: 'string' },
-          message: { type: 'string' }
+          message: { type: 'string' },
+          messageId: { type: 'string' },
+          targetMessage: { type: 'string', enum: ['last_inbound', 'last_outbound'] },
+          emoji: { type: 'string' },
+          replyToMessageId: { type: 'string' },
+          threadId: { type: 'string' },
+          delaySec: { type: 'number' },
+          followUpMessage: { type: 'string' },
+          followUpDelaySec: { type: 'number' },
+          dedupeKey: { type: 'string' },
         },
         required: ['action']
       },

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

@@ -34,9 +34,21 @@ export interface ToolBuildContext {
   activePlugins: string[]
 }
 
+function normalizeWorkspaceAlias(cwd: string, filePath: string): string {
+  const trimmed = filePath.trim()
+  if (!trimmed) return trimmed
+  if (trimmed === '/workspace' || trimmed === 'workspace') return cwd
+  if (trimmed.startsWith('/workspace/')) return trimmed.slice('/workspace/'.length)
+  if (trimmed.startsWith('workspace/')) return trimmed.slice('workspace/'.length)
+  return trimmed
+}
+
 export function safePath(cwd: string, filePath: string): string {
-  const resolved = require('path').resolve(cwd, filePath)
-  if (!resolved.startsWith(require('path').resolve(cwd))) {
+  const path = require('path')
+  const normalized = normalizeWorkspaceAlias(cwd, filePath)
+  const resolvedRoot = path.resolve(cwd)
+  const resolved = path.resolve(resolvedRoot, normalized)
+  if (!resolved.startsWith(resolvedRoot)) {
     throw new Error('Path traversal not allowed')
   }
   return resolved