@swarmclawai/swarmclaw 0.8.4 → 0.8.7

package/src/lib/server/alert-dispatch.ts

@@ -1,5 +1,6 @@
 import { loadSettings } from './storage'
 import type { AppNotification } from '@/types'
+import { errorMessage } from '@/lib/shared-utils'
 
 /** In-memory rate limiter: dedupKey → last dispatch timestamp */
 const recentDispatches = new Map<string, number>()
@@ -59,6 +60,6 @@ export async function dispatchAlert(notification: AppNotification): Promise<void
       signal: AbortSignal.timeout(5000),
     })
   } catch (err: unknown) {
-    console.warn('[alert-dispatch] Webhook delivery failed:', err instanceof Error ? err.message : String(err))
+    console.warn('[alert-dispatch] Webhook delivery failed:', errorMessage(err))
   }
 }

package/src/lib/server/api-routes.test.ts

@@ -230,13 +230,13 @@ describe('Knowledge API contract', () => {
   // --- Route file structure -----------------------------------------------
   describe('route file exports', () => {
     it('knowledge/route.ts exports GET and POST', () => {
-      const src = readRoute('knowledge', 'route.ts')
+      const src = readRoute('knowledge', 'route')
       assert.match(src, /export\s+async\s+function\s+GET/)
       assert.match(src, /export\s+async\s+function\s+POST/)
     })
 
     it('knowledge/[id]/route.ts exports GET, PUT, DELETE', () => {
-      const src = readRoute('knowledge', '[id]', 'route.ts')
+      const src = readRoute('knowledge', '[id]', 'route')
       assert.match(src, /export\s+async\s+function\s+GET/)
       assert.match(src, /export\s+async\s+function\s+PUT/)
       assert.match(src, /export\s+async\s+function\s+DELETE/)
@@ -334,25 +334,25 @@ describe('MCP Server API contract', () => {
   // --- Route file structure -----------------------------------------------
   describe('route file exports', () => {
     it('mcp-servers/route.ts exports GET and POST', () => {
-      const src = readRoute('mcp-servers', 'route.ts')
+      const src = readRoute('mcp-servers', 'route')
       assert.match(src, /export\s+async\s+function\s+GET/)
       assert.match(src, /export\s+async\s+function\s+POST/)
     })
 
     it('mcp-servers/[id]/route.ts exports GET, PUT, DELETE', () => {
-      const src = readRoute('mcp-servers', '[id]', 'route.ts')
+      const src = readRoute('mcp-servers', '[id]', 'route')
       assert.match(src, /export\s+async\s+function\s+GET/)
       assert.match(src, /export\s+async\s+function\s+PUT/)
       assert.match(src, /export\s+async\s+function\s+DELETE/)
     })
 
     it('MCP POST route assigns an id via genId helper', () => {
-      const src = readRoute('mcp-servers', 'route.ts')
+      const src = readRoute('mcp-servers', 'route')
       assert.match(src, /const\s+id\s*=\s*genId\(/)
     })
 
     it('MCP PUT route preserves id and sets updatedAt via mutateItem', () => {
-      const src = readRoute('mcp-servers', '[id]', 'route.ts')
+      const src = readRoute('mcp-servers', '[id]', 'route')
       assert.match(src, /mutateItem\(/)
       assert.match(src, /updatedAt:\s*Date\.now\(\)/)
       assert.match(src, /\.\.\.server,\s*\.\.\.body,\s*id,/)

package/src/lib/server/approval-connector-notify.test.ts

@@ -35,8 +35,8 @@ function runWithTempDataDir(script: string) {
 describe('approval connector reminders', () => {
   it('resolves a due approval to the session connector target and records one-shot delivery state', () => {
     const output = runWithTempDataDir(`
-      const storageMod = await import('./src/lib/server/storage.ts')
-      const approvalsMod = await import('./src/lib/server/approvals.ts')
+      const storageMod = await import('./src/lib/server/storage')
+      const approvalsMod = await import('./src/lib/server/approvals')
       const storage = storageMod.default || storageMod
       const approvals = approvalsMod.default || approvalsMod
 
@@ -148,8 +148,8 @@ describe('approval connector reminders', () => {
 
   it('falls back to a running owned connector and respects retry cooldowns after failed sends', () => {
     const output = runWithTempDataDir(`
-      const storageMod = await import('./src/lib/server/storage.ts')
-      const approvalsMod = await import('./src/lib/server/approvals.ts')
+      const storageMod = await import('./src/lib/server/storage')
+      const approvalsMod = await import('./src/lib/server/approvals')
       const storage = storageMod.default || storageMod
       const approvals = approvalsMod.default || approvalsMod
 

package/src/lib/server/approvals-auto-approve.test.ts

@@ -35,8 +35,8 @@ function runWithTempDataDir(script: string) {
 describe('approval auto-approve', () => {
   it('defaults new installs to approvals auto-run', () => {
     const output = runWithTempDataDir(`
-      const storageMod = await import('./src/lib/server/storage.ts')
-      const approvalsMod = await import('./src/lib/server/approvals.ts')
+      const storageMod = await import('./src/lib/server/storage')
+      const approvalsMod = await import('./src/lib/server/approvals')
       const storage = storageMod.default || storageMod
       const approvals = approvalsMod.default || approvalsMod
 
@@ -86,9 +86,9 @@ describe('approval auto-approve', () => {
 
   it('auto-approves tool access and plugin scaffolds when configured', () => {
     const output = runWithTempDataDir(`
-      const storageMod = await import('./src/lib/server/storage.ts')
-      const approvalsMod = await import('./src/lib/server/approvals.ts')
-      const dataDirMod = await import('./src/lib/server/data-dir.ts')
+      const storageMod = await import('./src/lib/server/storage')
+      const approvalsMod = await import('./src/lib/server/approvals')
+      const dataDirMod = await import('./src/lib/server/data-dir')
       const storage = storageMod.default || storageMod
       const approvals = approvalsMod.default || approvalsMod
       const dataDir = dataDirMod.DATA_DIR || dataDirMod.default?.DATA_DIR || dataDirMod['module.exports']?.DATA_DIR
@@ -164,9 +164,9 @@ describe('approval auto-approve', () => {
 
   it('can disable approvals platform-wide for fully autonomous execution', () => {
     const output = runWithTempDataDir(`
-      const storageMod = await import('./src/lib/server/storage.ts')
-      const approvalsMod = await import('./src/lib/server/approvals.ts')
-      const sessionRunsMod = await import('./src/lib/server/session-run-manager.ts')
+      const storageMod = await import('./src/lib/server/storage')
+      const approvalsMod = await import('./src/lib/server/approvals')
+      const sessionRunsMod = await import('./src/lib/server/session-run-manager')
       const storage = storageMod.default || storageMod
       const approvals = approvalsMod.default || approvalsMod
       const sessionRuns = sessionRunsMod.default || sessionRunsMod
@@ -225,8 +225,8 @@ describe('approval auto-approve', () => {
 
   it('adds a pending approval request message to the chat session when approvals are enabled', () => {
     const output = runWithTempDataDir(`
-      const storageMod = await import('./src/lib/server/storage.ts')
-      const approvalsMod = await import('./src/lib/server/approvals.ts')
+      const storageMod = await import('./src/lib/server/storage')
+      const approvalsMod = await import('./src/lib/server/approvals')
       const storage = storageMod.default || storageMod
       const approvals = approvalsMod.default || approvalsMod
 
@@ -288,9 +288,9 @@ describe('approval auto-approve', () => {
   it('injects approval guidance only from enabled plugins', () => {
     const output = runWithTempDataDir(`
       process.on('unhandledRejection', () => {})
-      await import('./src/lib/server/session-tools/wallet.ts')
-      const storageMod = await import('./src/lib/server/storage.ts')
-      const approvalsMod = await import('./src/lib/server/approvals.ts')
+      await import('./src/lib/server/session-tools/wallet')
+      const storageMod = await import('./src/lib/server/storage')
+      const approvalsMod = await import('./src/lib/server/approvals')
       const storage = storageMod.default || storageMod
       const approvals = approvalsMod.default || approvalsMod
 
@@ -424,9 +424,9 @@ describe('approval auto-approve', () => {
   it('derives tool-access approval guidance from the requested plugin metadata', () => {
     const output = runWithTempDataDir(`
       process.on('unhandledRejection', () => {})
-      await import('./src/lib/server/session-tools/http.ts')
-      const storageMod = await import('./src/lib/server/storage.ts')
-      const approvalsMod = await import('./src/lib/server/approvals.ts')
+      await import('./src/lib/server/session-tools/http')
+      const storageMod = await import('./src/lib/server/storage')
+      const approvalsMod = await import('./src/lib/server/approvals')
       const storage = storageMod.default || storageMod
       const approvals = approvalsMod.default || approvalsMod
 
@@ -478,9 +478,9 @@ describe('approval auto-approve', () => {
   it('injects plugin-owned scaffold guidance for plugin creator approvals', () => {
     const output = runWithTempDataDir(`
       process.on('unhandledRejection', () => {})
-      await import('./src/lib/server/session-tools/plugin-creator.ts')
-      const storageMod = await import('./src/lib/server/storage.ts')
-      const approvalsMod = await import('./src/lib/server/approvals.ts')
+      await import('./src/lib/server/session-tools/plugin-creator')
+      const storageMod = await import('./src/lib/server/storage')
+      const approvalsMod = await import('./src/lib/server/approvals')
       const storage = storageMod.default || storageMod
       const approvals = approvalsMod.default || approvalsMod
 
@@ -549,8 +549,8 @@ describe('approval auto-approve', () => {
   it('applies tool access after a manual approval decision', () => {
     const output = runWithTempDataDir(`
       process.on('unhandledRejection', () => {})
-      const storageMod = await import('./src/lib/server/storage.ts')
-      const approvalsMod = await import('./src/lib/server/approvals.ts')
+      const storageMod = await import('./src/lib/server/storage')
+      const approvalsMod = await import('./src/lib/server/approvals')
       const storage = storageMod.default || storageMod
       const approvals = approvalsMod.default || approvalsMod
 
@@ -609,9 +609,9 @@ describe('approval auto-approve', () => {
   it('wakes the blocked session after a manual approval decision', () => {
     const output = runWithTempDataDir(`
       process.on('unhandledRejection', () => {})
-      const storageMod = await import('./src/lib/server/storage.ts')
-      const approvalsMod = await import('./src/lib/server/approvals.ts')
-      const sessionRunsMod = await import('./src/lib/server/session-run-manager.ts')
+      const storageMod = await import('./src/lib/server/storage')
+      const approvalsMod = await import('./src/lib/server/approvals')
+      const sessionRunsMod = await import('./src/lib/server/session-run-manager')
       const storage = storageMod.default || storageMod
       const approvals = approvalsMod.default || approvalsMod
       const sessionRuns = sessionRunsMod.default || sessionRunsMod
@@ -672,14 +672,14 @@ describe('approval auto-approve', () => {
 
     assert.equal(output.finalStatus, 'approved')
     assert.equal(output.runCount >= 1, true)
-    assert.equal(output.runSources.filter((source) => source === 'approval-decision').length, 1)
+    assert.equal(output.runSources.filter((source: any) => source === "approval-decision").length, 1)
   })
 
   it('reuses equivalent wallet approvals instead of creating duplicates', () => {
     const output = runWithTempDataDir(`
       process.on('unhandledRejection', () => {})
-      const storageMod = await import('./src/lib/server/storage.ts')
-      const approvalsMod = await import('./src/lib/server/approvals.ts')
+      const storageMod = await import('./src/lib/server/storage')
+      const approvalsMod = await import('./src/lib/server/approvals')
       const storage = storageMod.default || storageMod
       const approvals = approvalsMod.default || approvalsMod
 
@@ -754,8 +754,8 @@ describe('approval auto-approve', () => {
 
   it('reuses approved tool-access decisions across sessions for the same agent', () => {
     const output = runWithTempDataDir(`
-      const storageMod = await import('./src/lib/server/storage.ts')
-      const approvalsMod = await import('./src/lib/server/approvals.ts')
+      const storageMod = await import('./src/lib/server/storage')
+      const approvalsMod = await import('./src/lib/server/approvals')
       const storage = storageMod.default || storageMod
       const approvals = approvalsMod.default || approvalsMod
 

package/src/lib/server/approvals.test.ts

@@ -0,0 +1,317 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { after, before, describe, it } from 'node:test'
+
+const originalEnv = {
+  DATA_DIR: process.env.DATA_DIR,
+  WORKSPACE_DIR: process.env.WORKSPACE_DIR,
+  SWARMCLAW_BUILD_MODE: process.env.SWARMCLAW_BUILD_MODE,
+}
+
+let tempDir = ''
+let approvals: typeof import('./approvals')
+let storage: typeof import('./storage')
+
+before(async () => {
+  tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-approvals-'))
+  process.env.DATA_DIR = path.join(tempDir, 'data')
+  process.env.WORKSPACE_DIR = path.join(tempDir, 'workspace')
+  process.env.SWARMCLAW_BUILD_MODE = '1'
+  storage = await import('./storage')
+  approvals = await import('./approvals')
+})
+
+after(() => {
+  if (originalEnv.DATA_DIR === undefined) delete process.env.DATA_DIR
+  else process.env.DATA_DIR = originalEnv.DATA_DIR
+  if (originalEnv.WORKSPACE_DIR === undefined) delete process.env.WORKSPACE_DIR
+  else process.env.WORKSPACE_DIR = originalEnv.WORKSPACE_DIR
+  if (originalEnv.SWARMCLAW_BUILD_MODE === undefined) delete process.env.SWARMCLAW_BUILD_MODE
+  else process.env.SWARMCLAW_BUILD_MODE = originalEnv.SWARMCLAW_BUILD_MODE
+  fs.rmSync(tempDir, { recursive: true, force: true })
+})
+
+describe('approvals', () => {
+  // ---- requestApproval ----
+
+  it('creates a pending approval with correct fields', () => {
+    const result = approvals.requestApproval({
+      category: 'tool_access',
+      title: 'Enable web',
+      data: { toolId: 'web' },
+      agentId: 'agent-1',
+      sessionId: 'session-1',
+    })
+
+    assert.equal(result.status, 'pending')
+    assert.equal(result.category, 'tool_access')
+    assert.equal(result.agentId, 'agent-1')
+    assert.equal(result.sessionId, 'session-1')
+    assert.ok(result.id.length > 0)
+    assert.ok(result.createdAt > 0)
+    assert.equal(result.createdAt, result.updatedAt)
+  })
+
+  it('normalizes tool_access title to "Enable Plugin: <id>"', () => {
+    const result = approvals.requestApproval({
+      category: 'tool_access',
+      title: 'Whatever title',
+      data: { toolId: 'shell' },
+    })
+    assert.equal(result.title, 'Enable Plugin: shell')
+  })
+
+  it('copies toolId to both toolId and pluginId for tool_access', () => {
+    const result = approvals.requestApproval({
+      category: 'tool_access',
+      title: 'test',
+      data: { toolId: 'browser' },
+    })
+    assert.equal(result.data.toolId, 'browser')
+    assert.equal(result.data.pluginId, 'browser')
+  })
+
+  it('throws when tool_access has no toolId or pluginId', () => {
+    assert.throws(() => {
+      approvals.requestApproval({
+        category: 'tool_access',
+        title: 'bad',
+        data: {},
+      })
+    }, /toolId or pluginId/)
+  })
+
+  it('allows non-tool_access categories without toolId', () => {
+    const result = approvals.requestApproval({
+      category: 'wallet_transfer',
+      title: 'Send 1 SOL',
+      data: { toAddress: 'abc', amountSol: 1 },
+    })
+    assert.equal(result.status, 'pending')
+    assert.equal(result.category, 'wallet_transfer')
+  })
+
+  // ---- listAutoApprovableApprovalCategories ----
+
+  it('returns a copy of auto-approvable categories', () => {
+    const cats = approvals.listAutoApprovableApprovalCategories()
+    assert.ok(cats.includes('tool_access'))
+    assert.ok(cats.includes('wallet_transfer'))
+    assert.ok(cats.includes('connector_sender'))
+    // Mutating the returned array shouldn't affect future calls
+    cats.push('fake' as never)
+    const cats2 = approvals.listAutoApprovableApprovalCategories()
+    assert.ok(!cats2.includes('fake' as never))
+  })
+
+  // ---- isApprovalCategoryAutoApproved ----
+
+  it('returns false when no auto-approve categories configured', () => {
+    assert.equal(approvals.isApprovalCategoryAutoApproved('tool_access'), false)
+  })
+
+  it('returns true when category is in the auto-approve list', () => {
+    // Configure auto-approve categories in settings
+    const settings = storage.loadSettings()
+    settings.approvalAutoApproveCategories = ['tool_access', 'wallet_transfer']
+    storage.saveSettings(settings)
+
+    assert.equal(approvals.isApprovalCategoryAutoApproved('tool_access'), true)
+    assert.equal(approvals.isApprovalCategoryAutoApproved('wallet_transfer'), true)
+    assert.equal(approvals.isApprovalCategoryAutoApproved('plugin_scaffold'), false)
+
+    // Clean up
+    settings.approvalAutoApproveCategories = []
+    storage.saveSettings(settings)
+  })
+
+  // ---- listPendingApprovals ----
+
+  it('lists only pending approvals sorted by updatedAt desc', () => {
+    // Create several approvals
+    const a1 = approvals.requestApproval({
+      category: 'tool_access',
+      title: 'A',
+      data: { toolId: 'a1tool' },
+    })
+    const a2 = approvals.requestApproval({
+      category: 'tool_access',
+      title: 'B',
+      data: { toolId: 'a2tool' },
+    })
+
+    const pending = approvals.listPendingApprovals()
+    const ids = pending.map((p) => p.id)
+    assert.ok(ids.includes(a1.id))
+    assert.ok(ids.includes(a2.id))
+    // All returned should be pending
+    for (const p of pending) {
+      assert.equal(p.status, 'pending')
+    }
+    // Sorted desc by updatedAt
+    for (let i = 1; i < pending.length; i++) {
+      assert.ok(pending[i - 1].updatedAt >= pending[i].updatedAt)
+    }
+  })
+
+  // ---- submitDecision ----
+
+  it('approves a pending request', async () => {
+    const req = approvals.requestApproval({
+      category: 'human_loop',
+      title: 'Confirm deployment',
+      data: { question: 'Deploy to prod?' },
+      sessionId: null,
+      agentId: null,
+    })
+    assert.equal(req.status, 'pending')
+
+    await approvals.submitDecision(req.id, true)
+
+    // Check it's no longer pending
+    const pending = approvals.listPendingApprovals()
+    assert.ok(!pending.some((p) => p.id === req.id))
+  })
+
+  it('rejects a pending request', async () => {
+    const req = approvals.requestApproval({
+      category: 'human_loop',
+      title: 'Confirm deletion',
+      data: { question: 'Delete everything?' },
+      sessionId: null,
+      agentId: null,
+    })
+
+    await approvals.submitDecision(req.id, false)
+
+    const pending = approvals.listPendingApprovals()
+    assert.ok(!pending.some((p) => p.id === req.id))
+  })
+
+  it('throws for non-existent approval id', async () => {
+    await assert.rejects(
+      () => approvals.submitDecision('nonexistent-xyz', true),
+      /not found/i,
+    )
+  })
+
+  it('is idempotent — approving an already-approved request is a no-op', async () => {
+    const req = approvals.requestApproval({
+      category: 'human_loop',
+      title: 'Idempotent test',
+      data: { question: 'yes?' },
+    })
+    await approvals.submitDecision(req.id, true)
+    // Should not throw
+    await approvals.submitDecision(req.id, true)
+  })
+
+  // ---- requestApprovalMaybeAutoApprove ----
+
+  it('auto-approves when approvalsEnabled is false', async () => {
+    const settings = storage.loadSettings()
+    settings.approvalsEnabled = false
+    storage.saveSettings(settings)
+
+    const result = await approvals.requestApprovalMaybeAutoApprove({
+      category: 'tool_access',
+      title: 'Auto test',
+      data: { toolId: 'auto_tool_1' },
+    })
+    assert.equal(result.status, 'approved')
+
+    settings.approvalsEnabled = true
+    storage.saveSettings(settings)
+  })
+
+  it('auto-approves when category is in auto-approve list', async () => {
+    const settings = storage.loadSettings()
+    settings.approvalAutoApproveCategories = ['wallet_transfer']
+    storage.saveSettings(settings)
+
+    const result = await approvals.requestApprovalMaybeAutoApprove({
+      category: 'wallet_transfer',
+      title: 'Auto transfer',
+      data: { toAddress: 'xyz_auto', amountSol: 0.5 },
+    })
+    assert.equal(result.status, 'approved')
+
+    settings.approvalAutoApproveCategories = []
+    storage.saveSettings(settings)
+  })
+
+  it('stays pending when approvals enabled and category not auto-approved', async () => {
+    const settings = storage.loadSettings()
+    settings.approvalsEnabled = true
+    settings.approvalAutoApproveCategories = []
+    storage.saveSettings(settings)
+
+    const result = await approvals.requestApprovalMaybeAutoApprove({
+      category: 'plugin_scaffold',
+      title: 'Manual scaffold',
+      data: { filename: 'test.js', code: 'module.exports = {}' },
+    })
+    assert.equal(result.status, 'pending')
+  })
+
+  // ---- markApprovalConnectorNotificationAttempt / Sent ----
+
+  it('records connector notification attempt', () => {
+    const req = approvals.requestApproval({
+      category: 'human_loop',
+      title: 'Notify test',
+      data: { question: 'hello?' },
+    })
+
+    const updated = approvals.markApprovalConnectorNotificationAttempt(req.id, {
+      at: 1000,
+      connectorId: 'conn-1',
+      channelId: 'ch-1',
+    })
+    assert.ok(updated)
+    assert.equal(updated!.connectorNotification?.attemptedAt, 1000)
+    assert.equal(updated!.connectorNotification?.connectorId, 'conn-1')
+    assert.equal(updated!.connectorNotification?.sentAt, undefined)
+  })
+
+  it('records connector notification sent', () => {
+    const req = approvals.requestApproval({
+      category: 'human_loop',
+      title: 'Sent test',
+      data: { question: 'done?' },
+    })
+
+    const updated = approvals.markApprovalConnectorNotificationSent(req.id, {
+      at: 2000,
+      connectorId: 'conn-2',
+      channelId: 'ch-2',
+      messageId: 'msg-123',
+    })
+    assert.ok(updated)
+    assert.equal(updated!.connectorNotification?.sentAt, 2000)
+    assert.equal(updated!.connectorNotification?.connectorId, 'conn-2')
+    assert.equal(updated!.connectorNotification?.messageId, 'msg-123')
+    assert.equal(updated!.connectorNotification?.lastError, null)
+  })
+
+  it('returns null for notification attempt on non-existent id', () => {
+    const result = approvals.markApprovalConnectorNotificationAttempt('ghost-id', { at: 1 })
+    assert.equal(result, null)
+  })
+
+  // ---- listPendingApprovalsNeedingConnectorNotification ----
+
+  it('returns empty when notification is disabled', () => {
+    const settings = storage.loadSettings()
+    settings.approvalConnectorNotifyEnabled = false
+    storage.saveSettings(settings)
+
+    const result = approvals.listPendingApprovalsNeedingConnectorNotification()
+    assert.deepEqual(result, [])
+
+    settings.approvalConnectorNotifyEnabled = true
+    storage.saveSettings(settings)
+  })
+})

package/src/lib/server/approvals.ts

@@ -1,6 +1,7 @@
 import { genId } from '@/lib/id'
 import { loadApprovals, upsertApproval, loadSessions, saveSessions, loadSettings, loadAgents } from './storage'
 import type { ApprovalRequest, ApprovalCategory, Message } from '@/types'
+import { dedup, errorMessage } from '@/lib/shared-utils'
 import { notify } from './ws-hub'
 import { log } from './logger'
 import { requestHeartbeatNow } from './heartbeat-wake'
@@ -67,7 +68,7 @@ function getEnabledPluginsForApproval(request: ApprovalRequest): string[] {
   const sessionPlugins = request.sessionId ? normalizePluginList(sessions[request.sessionId]?.plugins) : []
   const agentPlugins = request.agentId ? normalizePluginList(agents[request.agentId]?.plugins) : []
   const targetPlugins = getApprovalTargetPlugins(request)
-  return Array.from(new Set([...sessionPlugins, ...agentPlugins, ...targetPlugins]))
+  return dedup([...sessionPlugins, ...agentPlugins, ...targetPlugins])
 }
 
 function getApprovalGuidance(
@@ -533,7 +534,7 @@ async function applyApprovedSideEffects(request: ApprovalRequest): Promise<void>
       } catch (err: unknown) {
         log.error('approvals', 'Plugin scaffold dependency setup failed', {
           filename,
-          error: err instanceof Error ? err.message : String(err),
+          error: errorMessage(err),
         })
         await manager.savePluginSource(filename, code, {
           meta: createdByAgentId ? { createdByAgentId } : undefined,
@@ -573,7 +574,7 @@ async function applyApprovedSideEffects(request: ApprovalRequest): Promise<void>
       } catch (err: unknown) {
         log.error('approvals', 'Plugin install failed after approval', {
           url,
-          error: err instanceof Error ? err.message : String(err),
+          error: errorMessage(err),
         })
       }
     } else if (filename) {
@@ -596,7 +597,7 @@ async function applyApprovedSideEffects(request: ApprovalRequest): Promise<void>
       } catch (err: unknown) {
         log.error('approvals', 'Plugin dependency install failed after approval', {
           filename,
-          error: err instanceof Error ? err.message : String(err),
+          error: errorMessage(err),
         })
       }
     }

package/src/lib/server/autonomy-runtime.test.ts

@@ -35,8 +35,8 @@ function runWithTempDataDir(script: string) {
 describe('browser session persistence', () => {
   it('isolates browser profiles by default and stores observations', () => {
     const output = runWithTempDataDir(`
-      const storage = (await import('./src/lib/server/storage.ts')).default
-      const browserState = (await import('./src/lib/server/browser-state.ts')).default
+      const storage = (await import('./src/lib/server/storage')).default
+      const browserState = (await import('./src/lib/server/browser-state')).default
 
       const now = Date.now()
       storage.saveSessions({
@@ -99,7 +99,7 @@ describe('browser session persistence', () => {
 
   it('isolates subagent browser profiles by default unless sharing is explicitly requested', () => {
     const output = runWithTempDataDir(`
-      const mod = await import('./src/lib/server/session-tools/subagent.ts')
+      const mod = await import('./src/lib/server/session-tools/subagent')
       const { resolveSubagentBrowserProfileId } = mod.default || mod['module.exports'] || mod
 
       const parent = {
@@ -123,8 +123,8 @@ describe('durable watch jobs', () => {
     const output = runWithTempDataDir(`
       import fs from 'node:fs'
       import path from 'node:path'
-      const storage = (await import('./src/lib/server/storage.ts')).default
-      const watchJobs = (await import('./src/lib/server/watch-jobs.ts')).default
+      const storage = (await import('./src/lib/server/storage')).default
+      const watchJobs = (await import('./src/lib/server/watch-jobs')).default
 
       const watchFile = path.join(process.env.DATA_DIR, 'watch.txt')
       fs.writeFileSync(watchFile, 'build succeeded')
@@ -204,10 +204,10 @@ describe('durable watch jobs', () => {
 
   it('triggers mailbox and approval waits from human-loop events', () => {
     const output = runWithTempDataDir(`
-      const storage = (await import('./src/lib/server/storage.ts')).default
-      const watchJobs = (await import('./src/lib/server/watch-jobs.ts')).default
-      const mailboxMod = await import('./src/lib/server/session-mailbox.ts')
-      const approvalsMod = await import('./src/lib/server/approvals.ts')
+      const storage = (await import('./src/lib/server/storage')).default
+      const watchJobs = (await import('./src/lib/server/watch-jobs')).default
+      const mailboxMod = await import('./src/lib/server/session-mailbox')
+      const approvalsMod = await import('./src/lib/server/approvals')
       const mailbox = mailboxMod.default || mailboxMod
       const approvals = approvalsMod.default || approvalsMod
 
@@ -282,8 +282,8 @@ describe('durable watch jobs', () => {
 describe('delegation jobs', () => {
   it('preserves cancellation and recovers stale jobs', () => {
     const output = runWithTempDataDir(`
-      const delegationJobs = (await import('./src/lib/server/delegation-jobs.ts')).default
-      const storage = (await import('./src/lib/server/storage.ts')).default
+      const delegationJobs = (await import('./src/lib/server/delegation-jobs')).default
+      const storage = (await import('./src/lib/server/storage')).default
 
       let cancelledCalls = 0
       const cancelledJob = delegationJobs.createDelegationJob({

package/src/lib/server/browser-state.ts

@@ -1,7 +1,7 @@
 import fs from 'fs'
-import path from 'path'
 import type { BrowserObservation, BrowserSessionRecord, Session } from '@/types'
 import { BROWSER_PROFILES_DIR } from './data-dir'
+import { resolvePathWithinBaseDir } from './path-utils'
 import {
   deleteBrowserSession,
   loadBrowserSessions,
@@ -22,7 +22,7 @@ export function normalizeBrowserProfileId(value: unknown): string {
 
 export function getBrowserProfileDir(profileId: string): string {
   if (!fs.existsSync(BROWSER_PROFILES_DIR)) fs.mkdirSync(BROWSER_PROFILES_DIR, { recursive: true })
-  const dir = path.join(BROWSER_PROFILES_DIR, sanitizeToken(profileId))
+  const dir = resolvePathWithinBaseDir(BROWSER_PROFILES_DIR, sanitizeToken(profileId))
   if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true })
   return dir
 }

package/src/lib/server/capability-router.test.ts

@@ -1,6 +1,6 @@
 import assert from 'node:assert/strict'
 import { test } from 'node:test'
-import { routeTaskIntent } from './capability-router.ts'
+import { routeTaskIntent } from './capability-router'
 
 test('routeTaskIntent keeps recall-style prompts as general intent', () => {
   const decision = routeTaskIntent(