@swarmclawai/swarmclaw 0.8.0 → 0.8.2

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

@@ -46,7 +46,7 @@ describe('runtime settings defaults', () => {
     `)
 
     assert.equal(output.settings.loopMode, 'bounded')
-    assert.equal(output.settings.agentLoopRecursionLimit, 60)
+    assert.equal(output.settings.agentLoopRecursionLimit, 120)
     assert.equal(output.settings.orchestratorLoopRecursionLimit, 80)
     assert.equal(output.settings.legacyOrchestratorMaxTurns, 16)
     assert.equal(output.settings.ongoingLoopMaxIterations, 250)
@@ -61,7 +61,7 @@ describe('runtime settings defaults', () => {
     assert.equal(output.settings.heartbeatShowAlerts, true)
     assert.equal(output.settings.heartbeatTarget, null)
     assert.equal(output.settings.heartbeatPrompt, null)
-    assert.equal(output.runtime.agentLoopRecursionLimit, 60)
+    assert.equal(output.runtime.agentLoopRecursionLimit, 120)
     assert.equal(output.runtime.orchestratorLoopRecursionLimit, 80)
     assert.equal(output.runtime.legacyOrchestratorMaxTurns, 16)
   })

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

@@ -0,0 +1,136 @@
+import { after, before, describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import type { Agent } from '@/types'
+
+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 buildCrudTools: Awaited<typeof import('./crud')>['buildCrudTools']
+let loadAgents: Awaited<typeof import('../storage')>['loadAgents']
+let saveAgents: Awaited<typeof import('../storage')>['saveAgents']
+
+before(async () => {
+  tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-crud-test-'))
+  process.env.DATA_DIR = path.join(tempDir, 'data')
+  process.env.WORKSPACE_DIR = path.join(tempDir, 'workspace')
+  process.env.SWARMCLAW_BUILD_MODE = '1'
+  fs.mkdirSync(process.env.DATA_DIR, { recursive: true })
+  fs.mkdirSync(process.env.WORKSPACE_DIR, { recursive: true })
+
+  const crudMod = await import('./crud')
+  buildCrudTools = crudMod.buildCrudTools
+
+  const storageMod = await import('../storage')
+  loadAgents = storageMod.loadAgents
+  saveAgents = storageMod.saveAgents
+
+  const agents = loadAgents({ includeTrashed: true }) as Record<string, Agent>
+  agents['agent-soul-test'] = {
+    id: 'agent-soul-test',
+    name: 'Soul Test Agent',
+    description: 'Agent used for CRUD soul validation tests',
+    systemPrompt: '',
+    provider: 'ollama',
+    model: 'glm-5:cloud',
+    plugins: ['manage_agents'],
+    tools: ['manage_agents'],
+    platformAssignScope: 'self',
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+  }
+  saveAgents(agents)
+})
+
+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('manage_agents soul validation', () => {
+  it('rejects non-string soul payloads so preferences do not leak into agent config', async () => {
+    const tools = buildCrudTools({
+      cwd: process.cwd(),
+      ctx: { agentId: 'agent-soul-test', platformAssignScope: 'self' },
+      hasPlugin: (name) => name === 'manage_agents',
+      hasTool: (name) => name === 'manage_agents',
+      cleanupFns: [],
+      commandTimeoutMs: 1_000,
+      claudeTimeoutMs: 1_000,
+      cliProcessTimeoutMs: 1_000,
+      persistDelegateResumeId: () => {},
+      readStoredDelegateResumeId: () => null,
+      resolveCurrentSession: () => null,
+      activePlugins: ['manage_agents'],
+    })
+
+    const manageAgents = tools.find((tool) => tool.name === 'manage_agents')
+    assert.ok(manageAgents, 'expected manage_agents tool')
+
+    const raw = await manageAgents!.invoke({
+      action: 'update',
+      id: 'agent-soul-test',
+      soul: {
+        preferences: {
+          programmingLanguage: 'Rust',
+        },
+      },
+    })
+
+    assert.match(
+      String(raw),
+      /manage_agents data\.soul must be a plain instruction string/i,
+    )
+  })
+
+  it('deduplicates repeated manage_agents create calls in the same session', async () => {
+    const tools = buildCrudTools({
+      cwd: process.cwd(),
+      ctx: { sessionId: 'agent-dedupe-session', agentId: 'agent-soul-test', platformAssignScope: 'all' },
+      hasPlugin: (name) => name === 'manage_agents',
+      hasTool: (name) => name === 'manage_agents',
+      cleanupFns: [],
+      commandTimeoutMs: 1_000,
+      claudeTimeoutMs: 1_000,
+      cliProcessTimeoutMs: 1_000,
+      persistDelegateResumeId: () => {},
+      readStoredDelegateResumeId: () => null,
+      resolveCurrentSession: () => null,
+      activePlugins: ['manage_agents'],
+    })
+
+    const manageAgents = tools.find((tool) => tool.name === 'manage_agents')
+    assert.ok(manageAgents, 'expected manage_agents tool')
+
+    const firstRaw = await manageAgents!.invoke({
+      action: 'create',
+      name: 'Session Dedupe Worker',
+      soul: 'Coordinates a worker lane and never stores user memory.',
+    })
+    const secondRaw = await manageAgents!.invoke({
+      action: 'create',
+      name: 'Session Dedupe Worker',
+      soul: 'Coordinates a worker lane and never stores user memory.',
+    })
+
+    const first = JSON.parse(String(firstRaw)) as Record<string, unknown>
+    const second = JSON.parse(String(secondRaw)) as Record<string, unknown>
+    const created = Object.values(loadAgents({ includeTrashed: true }) as Record<string, Agent & { createdInSessionId?: string }>)
+      .filter((agent) => agent.createdInSessionId === 'agent-dedupe-session')
+
+    assert.equal(created.length, 1)
+    assert.equal(second.id, first.id)
+    assert.equal(second.deduplicated, true)
+  })
+})

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

@@ -118,6 +118,34 @@ function deriveTaskTitle(input: { title?: unknown; description?: unknown }): str
   return compact.slice(0, 120)
 }
 
+function validateAgentSoulPayload(value: unknown): string | null {
+  if (value === undefined) return null
+  if (typeof value === 'string') return null
+  return 'Error: manage_agents data.soul must be a plain instruction string. Use memory tools for user preferences, durable facts, and long-term memory instead.'
+}
+
+function findDuplicateManagedAgent(
+  all: Record<string, unknown>,
+  parsed: Record<string, unknown>,
+  ctx?: ToolBuildContext['ctx'],
+): Record<string, unknown> | null {
+  const requestedId = typeof parsed.id === 'string' ? parsed.id.trim() : ''
+  const requestedName = typeof parsed.name === 'string' ? parsed.name.trim().toLowerCase() : ''
+  if (!requestedId && !requestedName) return null
+
+  for (const candidate of Object.values(all)) {
+    if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)) continue
+    const record = candidate as Record<string, unknown>
+    if (requestedId && String(record.id || '').trim() === requestedId) return record
+    if (!requestedName) continue
+    const sameName = String(record.name || '').trim().toLowerCase() === requestedName
+    const sameSession = ctx?.sessionId && record.createdInSessionId === ctx.sessionId
+    if (sameName && sameSession) return record
+  }
+
+  return null
+}
+
 const VALID_CONNECTOR_PLATFORMS = new Set([
   'discord',
   'telegram',
@@ -562,7 +590,7 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
         description += `\n\nCurrent project context: "${ctx.projectName || ctx.projectId}" (projectId "${ctx.projectId}"). For get/update/delete, you may omit "id" to target this active project.`
       }
     } else if (toolKey === 'manage_agents') {
-      description += `\n\nAgents may self-edit their own soul. To update your soul, use action="update", id="${ctx?.agentId || 'your-agent-id'}", and include data with the "soul" field. Set "platformAssignScope":"all" to let an agent delegate work across the fleet; use "self" for solo execution.`
+      description += `\n\nAgents may self-edit their own soul only when explicitly changing persona or operating instructions. Do not use manage_agents to store user preferences, durable facts, or normal memory; use the memory tools for that. To update your soul, use action="update", id="${ctx?.agentId || 'your-agent-id'}", and include data with the "soul" field. Set "platformAssignScope":"all" to let an agent delegate work across the fleet; use "self" for solo execution.`
     } else if (toolKey === 'manage_schedules') {
       if (assignScope === 'self') {
         description += `\n\nOmit "agentId" to assign a schedule to yourself ("${ctx?.agentId || 'unknown'}"), or set it explicitly to yourself. You can only assign schedules to yourself. Schedule types: interval (set intervalMs), cron (set cron), once (set runAt). Provide either taskPrompt, command, or action+path. Before create, call list/get to avoid duplicate schedules. Reuse or update an existing schedule you already created in this chat instead of making a near-duplicate. If an equivalent active/paused schedule already exists, create returns that existing schedule (deduplicated=true). For one-off reminders, prefer "once"; agent-created one-off schedules are cleaned up automatically after they finish. When the user says stop/pause/cancel a reminder, pause or delete every matching schedule you created in this chat, not just one row.`
@@ -575,7 +603,7 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
     } else if (toolKey === 'manage_webhooks') {
       description += '\n\nUse `source`, `events`, `agentId`, and `secret` when creating webhooks. Inbound calls should POST to `/api/webhooks/{id}` with header `x-webhook-secret` when a secret is configured.'
     } else if (toolKey === 'manage_secrets') {
-      description += '\n\nUse this for credential bootstrapping and durable secret storage. Create/update calls accept either `data` as JSON or direct top-level fields like `name`, `service`, `value`, `scope`, `agentIds`, and `projectId`.'
+      description += '\n\nUse this only for credential bootstrapping and sensitive secret storage such as API keys, passwords, tokens, recovery codes, and webhook secrets. Do not use it for normal memory, user preferences, durable facts, or project notes. Create/update calls accept either `data` as JSON or direct top-level fields like `name`, `service`, `value`, `scope`, `agentIds`, and `projectId`.'
       if (ctx?.projectId) {
         description += `\n\nCurrent project context: "${ctx.projectName || ctx.projectId}" (projectId "${ctx.projectId}"). Omit "projectId" to link the secret to this active project.`
       }
@@ -757,6 +785,16 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
                     : null
                 }
               }
+              if (toolKey === 'manage_agents' && Object.prototype.hasOwnProperty.call(parsed, 'soul')) {
+                const soulError = validateAgentSoulPayload((parsed as Record<string, unknown>).soul)
+                if (soulError) return soulError
+              }
+              if (toolKey === 'manage_agents') {
+                const duplicateAgent = findDuplicateManagedAgent(all as Record<string, unknown>, parsed as Record<string, unknown>, ctx)
+                if (duplicateAgent) {
+                  return JSON.stringify({ ...duplicateAgent, deduplicated: true })
+                }
+              }
               // Task dedup
               if (toolKey === 'manage_tasks') {
                 const fp = computeTaskFingerprint(parsed.title || 'Untitled Task', parsed.agentId || ctx?.agentId || '')
@@ -851,6 +889,10 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
                   ? sanitizeConnectorCrudPayload(buildCrudPayload(normalized, action, data), { forUpdate: true })
                 : buildCrudPayload(normalized, action, data)
               const parsedRecord = parsed as Record<string, unknown>
+              if (toolKey === 'manage_agents' && Object.prototype.hasOwnProperty.call(parsedRecord, 'soul')) {
+                const soulError = validateAgentSoulPayload(parsedRecord.soul)
+                if (soulError) return soulError
+              }
               if (toolKey === 'manage_tasks') {
                 const continuationError = applyTaskContinuationDefaults(parsedRecord, all as Record<string, BoardTask>, parsedRecord)
                 if (continuationError) return continuationError

package/src/lib/server/session-tools/delegate-fallback.test.ts

@@ -131,6 +131,42 @@ describe('delegate fallback', () => {
     assert.match(String(output.response || ''), /codex fallback ok/i)
   })
 
+  it('rejects delegating a locally available tool call', () => {
+    const output = runWithFakeDelegates(`
+      const mod = await import('./src/lib/server/session-tools/delegate.ts')
+      const { buildDelegateTools } = mod.default || mod['module.exports'] || mod
+
+      const tools = buildDelegateTools({
+        cwd: process.cwd(),
+        ctx: { sessionId: 'session-test', agentId: 'agent-test', platformAssignScope: 'self' },
+        hasPlugin: (name) => name === 'delegate' || name === 'memory' || name === 'memory_store',
+        hasTool: (name) => name === 'delegate' || name === 'memory' || name === 'memory_store',
+        cleanupFns: [],
+        commandTimeoutMs: 5000,
+        claudeTimeoutMs: 5000,
+        cliProcessTimeoutMs: 5000,
+        persistDelegateResumeId: () => {},
+        readStoredDelegateResumeId: () => null,
+        resolveCurrentSession: () => null,
+        activePlugins: ['delegate', 'memory'],
+      })
+
+      const delegateTool = tools.find((tool) => tool.name === 'delegate')
+      const raw = await delegateTool.invoke({
+        input: JSON.stringify({
+          tool: 'memory_store',
+          args: {
+            title: 'User programming preferences',
+            value: 'Favorite language: Rust',
+          },
+        }),
+      })
+      console.log(JSON.stringify({ raw }))
+    `)
+
+    assert.match(String(output.raw || ''), /Call `memory` directly|Call `memory_store` directly|already available in this session/i)
+  })
+
   it('synthesizes a delegated task from write-style payloads', () => {
     const output = runWithFakeDelegates(`
       const mod = await import('./src/lib/server/session-tools/delegate.ts')

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

@@ -6,6 +6,7 @@ import { truncate, findBinaryOnPath, MAX_OUTPUT } from './context'
 import type { Plugin, PluginHooks } from '@/types'
 import { getPluginManager } from '../plugins'
 import { normalizeToolInputArgs } from './normalize-tool-args'
+import { canonicalizePluginId } from '../tool-aliases'
 import {
   appendDelegationCheckpoint,
   cancelDelegationJob,
@@ -277,6 +278,30 @@ function normalizeDelegateArgs(rawArgs: Record<string, unknown>): Record<string,
   return normalized
 }
 
+function resolveDirectLocalToolDelegationTarget(
+  normalized: Record<string, unknown>,
+  bctx: DelegateContext,
+): string | null {
+  const requestedTool = [
+    normalized.tool,
+    normalized.tool_name,
+    normalized.toolName,
+    normalized.tool_id,
+    normalized.toolId,
+  ].find((value) => typeof value === 'string' && value.trim()) as string | undefined
+  const trimmed = typeof requestedTool === 'string' ? requestedTool.trim() : ''
+  if (!trimmed) return null
+  if (coerceDelegateBackend(trimmed)) return null
+
+  const canonical = canonicalizePluginId(trimmed) || trimmed.toLowerCase()
+  if (canonical === 'delegate') return null
+  const hasLocalTool = bctx.hasPlugin?.(trimmed)
+    || bctx.hasPlugin?.(canonical)
+    || bctx.hasTool?.(trimmed)
+    || bctx.hasTool?.(canonical)
+  return hasLocalTool ? canonical : null
+}
+
 function resolveDelegateSessionId(bctx: DelegateContext): string | null {
   const nested = typeof bctx.ctx?.sessionId === 'string' ? bctx.ctx.sessionId.trim() : ''
   if (nested) return nested
@@ -459,6 +484,7 @@ async function waitForDelegateJob(jobId: string, timeoutSec = 30): Promise<strin
 async function executeDelegateAction(args: Record<string, unknown>, bctx: DelegateContext) {
   const normalized = normalizeDelegateArgs(args)
   const action = String(normalized.action || '').trim().toLowerCase()
+  const directLocalToolTarget = resolveDirectLocalToolDelegationTarget(normalized, bctx)
   const task = normalized.task as string
   const requestedBackend = ((normalized.backend as string) || 'claude') as DelegateBackend
   const jobId = typeof normalized.jobId === 'string' ? normalized.jobId.trim() : ''
@@ -488,6 +514,10 @@ async function executeDelegateAction(args: Record<string, unknown>, bctx: Delega
     return waitForDelegateJob(jobId, timeoutSec)
   }
 
+  if (directLocalToolTarget) {
+    return `Error: \`${directLocalToolTarget}\` is already available in this session. Call \`${directLocalToolTarget}\` directly instead of wrapping it inside \`delegate\`.`
+  }
+
   if (!task) return 'Error: task is required.'
 
   const job = createDelegationJob({

package/src/lib/server/session-tools/discovery-approvals.test.ts

@@ -128,6 +128,46 @@ describe('discovery approval flows', () => {
     assert.equal(output.plugins.includes('shell'), true)
   })
 
+  it('manage_capabilities request_access tells the agent to call already-available alias tools directly', () => {
+    const output = runWithTempDataDir(`
+      const storageMod = await import('./src/lib/server/storage.ts')
+      const toolsMod = await import('./src/lib/server/session-tools/index.ts')
+      const storage = storageMod.default || storageMod
+      const toolsApi = toolsMod.default || toolsMod
+
+      const now = Date.now()
+      storage.saveSessions({
+        session_memory: {
+          id: 'session_memory',
+          name: 'Memory Alias Test',
+          cwd: process.env.WORKSPACE_DIR,
+          user: 'tester',
+          provider: 'openai',
+          model: 'gpt-test',
+          claudeSessionId: null,
+          messages: [],
+          createdAt: now,
+          lastActiveAt: now,
+          sessionType: 'human',
+          agentId: 'default',
+          plugins: ['memory'],
+        },
+      })
+
+      const built = await toolsApi.buildSessionTools(process.env.WORKSPACE_DIR, ['memory'], {
+        sessionId: 'session_memory',
+        agentId: 'default',
+        platformAssignScope: 'self',
+      })
+      const tool = built.tools.find((entry) => entry.name === 'manage_capabilities')
+      const raw = await tool.invoke({ action: 'request_access', query: 'memory_store', reason: 'Need to remember a user preference.' })
+      console.log(JSON.stringify({ raw }))
+    `)
+
+    assert.match(String(output.raw), /"alreadyAvailable":true/)
+    assert.match(String(output.raw), /memory_store\\\" directly now/i)
+  })
+
   it('granting manage_schedules does not surface the manage_platform umbrella tool', () => {
     const output = runWithTempDataDir(`
       const storageMod = await import('./src/lib/server/storage.ts')

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

@@ -142,12 +142,13 @@ async function executeDiscoveryAction(args: Record<string, unknown>, bctx?: Tool
           const currentSession = allSessions[bctx.ctx.sessionId]
           const grantedTools = currentSession?.plugins || currentSession?.tools || []
           if (currentSession && pluginIdMatches(grantedTools, pluginId)) {
-          return JSON.stringify({
-            alreadyGranted: true,
-            pluginId,
-            message: `You already have access to "${pluginId}". If it was just granted, it will be available on the next agent turn.`,
-          })
-        }
+            return JSON.stringify({
+              alreadyGranted: true,
+              alreadyAvailable: true,
+              pluginId,
+              message: `You already have access to "${pluginId}" in this session. Call "${pluginId}" directly now instead of using manage_capabilities again.`,
+            })
+          }
         }
         const { requestApprovalMaybeAutoApprove } = await import('../approvals')
         const approval = await requestApprovalMaybeAutoApprove({

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

@@ -35,6 +35,7 @@ type MemoryActionContext = Partial<Session> & {
 }
 
 type MemorySearchSource = 'durable' | 'working' | 'archive' | 'all'
+type NarrowMemoryAction = 'search' | 'get' | 'store' | 'update'
 type CanonicalMemoryCandidate = {
   entry: MemoryEntry
   score: number
@@ -150,6 +151,24 @@ function normalizeMemoryText(value: unknown): string {
     .trim()
 }
 
+function buildNamedMemoryActionArgs(
+  action: NarrowMemoryAction,
+  args: Record<string, unknown>,
+): Record<string, unknown> {
+  return { ...args, action }
+}
+
+function executeNamedMemoryAction(
+  action: NarrowMemoryAction,
+  args: Record<string, unknown>,
+  context: { session?: MemoryActionContext | null } | null | undefined,
+) {
+  return executeMemoryAction(
+    buildNamedMemoryActionArgs(action, normalizeToolInputArgs((args ?? {}) as Record<string, unknown>)),
+    context?.session,
+  )
+}
+
 function stripGeneratedMemoryPrefix(value: string): string {
   return value.replace(/^\[(?:auto|auto-consolidated)[^\]]*\]\s*/i, '').trim()
 }
@@ -763,11 +782,15 @@ const MemoryPlugin: Plugin = {
         ctx.session.lastAutoMemoryAt = now
       } catch { /* auto-memory is best-effort */ }
     },
-    getCapabilityDescription: () => 'I have long-term memory (`memory_tool`) — I can remember things across conversations and recall them when needed.',
+    getCapabilityDescription: () => 'I have long-term memory (`memory_search`, `memory_get`, `memory_store`, `memory_update`, `memory_tool`) — I can remember things across conversations and recall them when needed.',
     getOperatingGuidance: () => [
-      'Memory: use memory_tool only when recalling past conversations or when explicitly asked to remember. For info already in the current conversation, respond directly without tool calls.',
-      'When the user directly says to remember, store, or correct a fact, do one memory_tool store/update call immediately. Treat the newest direct user statement as authoritative.',
-      'memory_tool store/update now merges canonical memories and retires superseded variants. After a successful store/update, do not keep re-searching unless the user explicitly asked you to verify.',
+      'Memory: use narrow memory tools first. For past-conversation recall, prefer `memory_search` then `memory_get`. For direct writes or corrections, prefer `memory_store` or `memory_update`. Keep `memory_tool` for list/delete/link/doctor or when you truly need the generic surface.',
+      'For info already in the current conversation, respond directly without calling any memory tool.',
+      'For questions about prior work, decisions, dates, people, preferences, or todos from earlier conversations: start with one durable `memory_search`, then use `memory_get` only if you need a more targeted read. Only use archive/session history when the user explicitly needs transcript-level detail or the durable search is insufficient.',
+      'When the user directly says to remember, store, or correct a fact, do one `memory_store` or `memory_update` call immediately. Treat the newest direct user statement as authoritative.',
+      'When one user message contains multiple related facts to remember, prefer one canonical `memory_store` write that captures the full set instead of many near-duplicate store calls.',
+      'If someone says "remember this", write it down; do not rely on RAM alone.',
+      'Memory writes merge canonical memories and retire superseded variants. After a successful store/update, do not keep re-searching unless the user explicitly asked you to verify.',
       'By default, memory searches focus on durable memories. Only include archives or working execution notes when you explicitly need transcript or run-history context.',
       'For open goals, form a hypothesis and execute — do not keep re-asking broad questions.',
     ],
@@ -794,7 +817,102 @@ const MemoryPlugin: Plugin = {
       },
       execute: async (args, context) => {
         return executeMemoryAction(args, context.session)
-      }
+      },
+      planning: {
+        capabilities: ['memory.search', 'memory.write'],
+        disciplineGuidance: [
+          'Use `memory_tool` for broad memory administration such as list, delete, link, unlink, or doctor. Prefer the narrow memory tools for routine search/get/store/update work.',
+        ],
+      },
+    },
+    {
+      name: 'memory_search',
+      description: 'Search durable long-term memory for prior work, decisions, dates, people, preferences, or todos from earlier conversations. Prefer this before broader history tools.',
+      parameters: {
+        type: 'object',
+        properties: {
+          query: { type: 'string' },
+          scope: { type: 'string', enum: ['auto', 'all', 'global', 'shared', 'agent', 'session', 'project'] },
+          sources: { type: 'array', items: { type: 'string', enum: ['durable', 'working', 'archive', 'all'] } },
+          rerank: { type: 'string', enum: ['balanced', 'semantic', 'lexical'] },
+        },
+        required: ['query'],
+      },
+      planning: {
+        capabilities: ['memory.search'],
+        disciplineGuidance: [
+          'For earlier-conversation recall, start with `memory_search` instead of browsing archive/session history. Keep searches durable-first unless transcript or run-history detail is explicitly needed.',
+        ],
+      },
+      execute: async (args, context) => executeNamedMemoryAction('search', args, context),
+    },
+    {
+      name: 'memory_get',
+      description: 'Read a specific memory entry by id or key after search, keeping context focused.',
+      parameters: {
+        type: 'object',
+        properties: {
+          id: { type: 'string' },
+          key: { type: 'string' },
+          scope: { type: 'string', enum: ['auto', 'all', 'global', 'shared', 'agent', 'session', 'project'] },
+        },
+        required: [],
+      },
+      planning: {
+        capabilities: ['memory.search'],
+        disciplineGuidance: [
+          'Use `memory_get` after `memory_search` when you need one targeted memory entry. Do not dump the whole memory list when a single entry is enough.',
+        ],
+      },
+      execute: async (args, context) => executeNamedMemoryAction('get', args, context),
+    },
+    {
+      name: 'memory_store',
+      description: 'Store a durable fact, preference, decision, or correction from the user. Use this immediately when the user says to remember something. If several related facts arrive in one request, prefer one canonical write over many near-duplicate calls.',
+      parameters: {
+        type: 'object',
+        properties: {
+          title: { type: 'string' },
+          value: { type: 'string' },
+          category: { type: 'string' },
+          key: { type: 'string' },
+          scope: { type: 'string', enum: ['auto', 'all', 'global', 'shared', 'agent', 'session', 'project'] },
+          sharedWith: { type: 'array', items: { type: 'string' } },
+        },
+        required: [],
+      },
+      planning: {
+        capabilities: ['memory.write'],
+        disciplineGuidance: [
+          'When the user says to remember or store a fact, call `memory_store` immediately. Do not delegate or use platform-management tools first.',
+          'If the user bundled multiple related facts into one remember request, store them together in one canonical write unless they asked for separate memories.',
+        ],
+      },
+      execute: async (args, context) => executeNamedMemoryAction('store', args, context),
+    },
+    {
+      name: 'memory_update',
+      description: 'Update or correct an existing durable memory when new information supersedes the old value.',
+      parameters: {
+        type: 'object',
+        properties: {
+          id: { type: 'string' },
+          key: { type: 'string' },
+          title: { type: 'string' },
+          value: { type: 'string' },
+          category: { type: 'string' },
+          query: { type: 'string' },
+          scope: { type: 'string', enum: ['auto', 'all', 'global', 'shared', 'agent', 'session', 'project'] },
+        },
+        required: [],
+      },
+      planning: {
+        capabilities: ['memory.write'],
+        disciplineGuidance: [
+          'When the user corrects or revises remembered information, prefer `memory_update` so the canonical durable memory is updated instead of creating noisy duplicates.',
+        ],
+      },
+      execute: async (args, context) => executeNamedMemoryAction('update', args, context),
     }
   ]
 }
@@ -813,6 +931,38 @@ export function buildMemoryTools(bctx: ToolBuildContext) {
         description: MemoryPlugin.tools![0].description,
         schema: z.object({}).passthrough()
       }
-    )
+    ),
+    tool(
+      async (args) => executeNamedMemoryAction('search', (args ?? {}) as Record<string, unknown>, { session: bctx.ctx }),
+      {
+        name: 'memory_search',
+        description: MemoryPlugin.tools![1].description,
+        schema: z.object({}).passthrough(),
+      },
+    ),
+    tool(
+      async (args) => executeNamedMemoryAction('get', (args ?? {}) as Record<string, unknown>, { session: bctx.ctx }),
+      {
+        name: 'memory_get',
+        description: MemoryPlugin.tools![2].description,
+        schema: z.object({}).passthrough(),
+      },
+    ),
+    tool(
+      async (args) => executeNamedMemoryAction('store', (args ?? {}) as Record<string, unknown>, { session: bctx.ctx }),
+      {
+        name: 'memory_store',
+        description: MemoryPlugin.tools![3].description,
+        schema: z.object({}).passthrough(),
+      },
+    ),
+    tool(
+      async (args) => executeNamedMemoryAction('update', (args ?? {}) as Record<string, unknown>, { session: bctx.ctx }),
+      {
+        name: 'memory_update',
+        description: MemoryPlugin.tools![4].description,
+        schema: z.object({}).passthrough(),
+      },
+    ),
   ]
 }

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

@@ -138,6 +138,18 @@ describe('memory tool knowledge actions (source verification)', () => {
     assert.equal(enumBody.includes("'knowledge_store'"), false)
     assert.equal(enumBody.includes("'knowledge_search'"), false)
   })
+
+  it('declares the narrow OpenClaw-style memory tool names', async () => {
+    const fs = await import('fs')
+    const src = fs.readFileSync(
+      new URL('./memory.ts', import.meta.url).pathname,
+      'utf-8',
+    )
+
+    for (const toolName of ['memory_search', 'memory_get', 'memory_store', 'memory_update']) {
+      assert.ok(src.includes(`name: '${toolName}'`), `memory.ts should declare ${toolName}`)
+    }
+  })
 })
 
 // ---------------------------------------------------------------------------

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

@@ -120,7 +120,7 @@ async function startSubagentJob(jobId: string, args: {
       const latest = getDelegationJob(jobId)
       if (latest?.status === 'cancelled') return
       appendDelegationCheckpoint(jobId, 'Child session completed', 'completed')
-      completeDelegationJob(jobId, result.text.slice(0, 8000), { childSessionId: sid })
+      completeDelegationJob(jobId, result.text.slice(0, 32_000), { childSessionId: sid })
     })
     .catch((err: unknown) => {
       const message = err instanceof Error ? err.message : String(err)
@@ -213,10 +213,10 @@ async function executeSubagentAction(args: any, context: { sessionId?: string; c
       agentId,
       agentName: started.agent.name,
       sessionId: started.sid,
-      response: result.text.slice(0, 8000),
+      response: result.text.slice(0, 32_000),
     })
-  } catch (err: any) {
-    return `Error: ${err.message}`
+  } catch (err: unknown) {
+    return `Error: ${err instanceof Error ? err.message : String(err)}`
   }
 }