@swarmclawai/swarmclaw 0.7.3 → 0.7.5

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

@@ -1,15 +1,6 @@
 import type { LoopMode } from '@/types'
 import {
-  DEFAULT_AGENT_LOOP_RECURSION_LIMIT,
-  DEFAULT_CLAUDE_CODE_TIMEOUT_SEC,
-  DEFAULT_CLI_PROCESS_TIMEOUT_SEC,
-  DEFAULT_DELEGATION_MAX_DEPTH,
-  DEFAULT_LEGACY_ORCHESTRATOR_MAX_TURNS,
-  DEFAULT_LOOP_MODE,
-  DEFAULT_ONGOING_LOOP_MAX_ITERATIONS,
-  DEFAULT_ONGOING_LOOP_MAX_RUNTIME_MINUTES,
-  DEFAULT_ORCHESTRATOR_LOOP_RECURSION_LIMIT,
-  DEFAULT_SHELL_COMMAND_TIMEOUT_SEC,
+  normalizeRuntimeSettingFields,
 } from '@/lib/runtime-loop'
 import { loadSettings } from './storage'
 
@@ -26,92 +17,21 @@ export interface RuntimeSettings {
   cliProcessTimeoutMs: number
 }
 
-function parseIntSetting(value: unknown, fallback: number, min: number, max: number): number {
-  const parsed = typeof value === 'number'
-    ? value
-    : typeof value === 'string'
-      ? Number.parseInt(value, 10)
-      : Number.NaN
-  if (!Number.isFinite(parsed)) return fallback
-  const int = Math.trunc(parsed)
-  return Math.max(min, Math.min(max, int))
-}
-
-function parseLoopMode(value: unknown): LoopMode {
-  return value === 'ongoing' ? 'ongoing' : DEFAULT_LOOP_MODE
-}
-
 export function loadRuntimeSettings(): RuntimeSettings {
   const settings = loadSettings()
-  const loopMode = parseLoopMode(settings.loopMode)
-
-  const agentLoopRecursionLimit = parseIntSetting(
-    settings.agentLoopRecursionLimit,
-    DEFAULT_AGENT_LOOP_RECURSION_LIMIT,
-    1,
-    200,
-  )
-  const orchestratorLoopRecursionLimit = parseIntSetting(
-    settings.orchestratorLoopRecursionLimit,
-    DEFAULT_ORCHESTRATOR_LOOP_RECURSION_LIMIT,
-    1,
-    300,
-  )
-  const legacyOrchestratorMaxTurns = parseIntSetting(
-    settings.legacyOrchestratorMaxTurns,
-    DEFAULT_LEGACY_ORCHESTRATOR_MAX_TURNS,
-    1,
-    300,
-  )
-  const delegationMaxDepth = parseIntSetting(
-    settings.delegationMaxDepth,
-    DEFAULT_DELEGATION_MAX_DEPTH,
-    1,
-    12,
-  )
-  const ongoingLoopMaxIterations = parseIntSetting(
-    settings.ongoingLoopMaxIterations,
-    DEFAULT_ONGOING_LOOP_MAX_ITERATIONS,
-    10,
-    5000,
-  )
-  const ongoingLoopMaxRuntimeMinutes = parseIntSetting(
-    settings.ongoingLoopMaxRuntimeMinutes,
-    DEFAULT_ONGOING_LOOP_MAX_RUNTIME_MINUTES,
-    0,
-    1440,
-  )
-
-  const shellCommandTimeoutSec = parseIntSetting(
-    settings.shellCommandTimeoutSec,
-    DEFAULT_SHELL_COMMAND_TIMEOUT_SEC,
-    1,
-    600,
-  )
-  const claudeCodeTimeoutSec = parseIntSetting(
-    settings.claudeCodeTimeoutSec,
-    DEFAULT_CLAUDE_CODE_TIMEOUT_SEC,
-    5,
-    7200,
-  )
-  const cliProcessTimeoutSec = parseIntSetting(
-    settings.cliProcessTimeoutSec,
-    DEFAULT_CLI_PROCESS_TIMEOUT_SEC,
-    10,
-    7200,
-  )
+  const normalized = normalizeRuntimeSettingFields(settings)
 
   return {
-    loopMode,
-    agentLoopRecursionLimit,
-    orchestratorLoopRecursionLimit,
-    legacyOrchestratorMaxTurns,
-    delegationMaxDepth,
-    ongoingLoopMaxIterations,
-    ongoingLoopMaxRuntimeMs: ongoingLoopMaxRuntimeMinutes > 0 ? ongoingLoopMaxRuntimeMinutes * 60_000 : null,
-    shellCommandTimeoutMs: shellCommandTimeoutSec * 1000,
-    claudeCodeTimeoutMs: claudeCodeTimeoutSec * 1000,
-    cliProcessTimeoutMs: cliProcessTimeoutSec * 1000,
+    loopMode: normalized.loopMode as LoopMode,
+    agentLoopRecursionLimit: normalized.agentLoopRecursionLimit,
+    orchestratorLoopRecursionLimit: normalized.orchestratorLoopRecursionLimit,
+    legacyOrchestratorMaxTurns: normalized.legacyOrchestratorMaxTurns,
+    delegationMaxDepth: normalized.delegationMaxDepth,
+    ongoingLoopMaxIterations: normalized.ongoingLoopMaxIterations,
+    ongoingLoopMaxRuntimeMs: normalized.ongoingLoopMaxRuntimeMinutes > 0 ? normalized.ongoingLoopMaxRuntimeMinutes * 60_000 : null,
+    shellCommandTimeoutMs: normalized.shellCommandTimeoutSec * 1000,
+    claudeCodeTimeoutMs: normalized.claudeCodeTimeoutSec * 1000,
+    cliProcessTimeoutMs: normalized.cliProcessTimeoutSec * 1000,
   }
 }
 

package/src/lib/server/schedule-normalization.ts

@@ -0,0 +1,187 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { WORKSPACE_DIR } from './data-dir'
+
+type SchedulePayload = Record<string, unknown>
+
+export interface NormalizeScheduleOptions {
+  cwd?: string | null
+  now?: number
+}
+
+export type NormalizeScheduleResult =
+  | { ok: true; value: SchedulePayload }
+  | { ok: false; error: string }
+
+const SCRIPT_FILE_EXT = /\.(py|js|mjs|cjs|ts|tsx|sh|bash|zsh|rb|php|pl)$/i
+const DIRECT_SCRIPT_RUNNERS = new Set(['python', 'python3', 'python3.11', 'node', 'bash', 'sh', 'zsh', 'ruby', 'tsx', 'ts-node'])
+const VALID_STATUSES = new Set(['active', 'paused', 'completed', 'failed'])
+
+function trimString(value: unknown): string {
+  return typeof value === 'string' ? value.trim() : ''
+}
+
+function normalizeScheduleType(value: unknown): 'cron' | 'interval' | 'once' {
+  if (value === 'cron' || value === 'interval' || value === 'once') return value
+  return 'interval'
+}
+
+function normalizePositiveInt(value: unknown): number | null {
+  const parsed = typeof value === 'number'
+    ? value
+    : typeof value === 'string'
+      ? Number.parseInt(value, 10)
+      : Number.NaN
+  if (!Number.isFinite(parsed)) return null
+  const intValue = Math.trunc(parsed)
+  return intValue > 0 ? intValue : null
+}
+
+function isWithinDirectory(parent: string, child: string): boolean {
+  const relative = path.relative(path.resolve(parent), path.resolve(child))
+  return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative))
+}
+
+function resolveRelativePath(baseDir: string, candidate: string): string | null {
+  const trimmed = trimString(candidate)
+  if (!trimmed) return null
+  if (path.isAbsolute(trimmed)) {
+    const resolvedAbsolute = path.resolve(trimmed)
+    return isWithinDirectory(baseDir, resolvedAbsolute) ? resolvedAbsolute : null
+  }
+  const resolved = path.resolve(baseDir, trimmed)
+  return isWithinDirectory(baseDir, resolved) ? resolved : null
+}
+
+function tokenizeCommand(command: string): string[] {
+  return String(command || '').match(/(?:[^\s"'`]+|"[^"]*"|'[^']*')+/g) || []
+}
+
+function unquoteToken(token: string): string {
+  if ((token.startsWith('"') && token.endsWith('"')) || (token.startsWith('\'') && token.endsWith('\''))) {
+    return token.slice(1, -1)
+  }
+  return token
+}
+
+function looksLikeScriptPath(token: string): boolean {
+  return SCRIPT_FILE_EXT.test(token) || token.includes('/') || token.includes(path.sep)
+}
+
+function extractScriptPathFromCommand(command: string): string | null {
+  const tokens = tokenizeCommand(command).map(unquoteToken).filter(Boolean)
+  if (!tokens.length) return null
+
+  const commandName = path.basename(tokens[0] || '').toLowerCase()
+  let startIndex = 1
+  if (commandName === 'npx' && tokens[1]) {
+    const nestedRunner = path.basename(tokens[1]).toLowerCase()
+    if (nestedRunner === 'tsx' || nestedRunner === 'ts-node') startIndex = 2
+  } else if (commandName === 'deno' && tokens[1] === 'run') {
+    startIndex = 2
+  } else if (!DIRECT_SCRIPT_RUNNERS.has(commandName)) {
+    startIndex = 0
+  }
+
+  for (let index = startIndex; index < tokens.length; index += 1) {
+    const candidate = tokens[index]
+    if (!candidate || candidate.startsWith('-')) continue
+    if (!looksLikeScriptPath(candidate)) continue
+    return candidate
+  }
+
+  return null
+}
+
+function deriveTaskPrompt(payload: SchedulePayload): string {
+  const explicitTaskPrompt = trimString(payload.taskPrompt)
+  if (explicitTaskPrompt) return explicitTaskPrompt
+
+  const command = trimString(payload.command)
+  if (command) {
+    return `Execute the command \`${command}\` from this schedule's working directory and report the result, including any errors.`
+  }
+
+  const filePath = trimString(payload.path)
+  if (!filePath) return ''
+
+  const action = trimString(payload.action).toLowerCase()
+  if (action === 'run_script') {
+    return `Run the script at \`${filePath}\` from this schedule's working directory and report the result, including any errors.`
+  }
+
+  return `Use the file at \`${filePath}\` to complete this scheduled task and report the result.`
+}
+
+function validateScheduleArtifacts(payload: SchedulePayload, baseDir: string): string | null {
+  const action = trimString(payload.action).toLowerCase()
+  const filePath = trimString(payload.path)
+  const command = trimString(payload.command)
+
+  if (action === 'run_script' && !filePath) {
+    return 'run_script schedules require a path.'
+  }
+
+  if (filePath) {
+    const resolved = resolveRelativePath(baseDir, filePath)
+    if (!resolved) return `schedule path must stay inside ${baseDir}: ${filePath}`
+    if (!fs.existsSync(resolved)) return `schedule path not found: ${filePath}`
+  }
+
+  if (!command) return null
+  const commandScriptPath = extractScriptPathFromCommand(command)
+  if (!commandScriptPath) return null
+  const resolved = resolveRelativePath(baseDir, commandScriptPath)
+  if (!resolved) return `schedule command references a path outside ${baseDir}: ${commandScriptPath}`
+  if (!fs.existsSync(resolved)) return `schedule command references a missing file: ${commandScriptPath}`
+  return null
+}
+
+export function normalizeSchedulePayload(payload: SchedulePayload, opts: NormalizeScheduleOptions = {}): NormalizeScheduleResult {
+  const now = typeof opts.now === 'number' ? opts.now : Date.now()
+  const baseDir = path.resolve(trimString(opts.cwd) || WORKSPACE_DIR)
+  const normalized: SchedulePayload = {
+    ...payload,
+    scheduleType: normalizeScheduleType(payload.scheduleType),
+  }
+  const action = trimString(normalized.action)
+  const command = trimString(normalized.command)
+  const filePath = trimString(normalized.path)
+  if (action) normalized.action = action
+  if (command) normalized.command = command
+  if (filePath) normalized.path = filePath
+
+  const status = trimString(normalized.status).toLowerCase()
+  normalized.status = VALID_STATUSES.has(status) ? status : 'active'
+
+  const agentId = trimString(normalized.agentId)
+  if (!agentId) {
+    return { ok: false, error: 'Error: schedules require a target agentId.' }
+  }
+  normalized.agentId = agentId
+
+  const taskPrompt = deriveTaskPrompt(normalized)
+  if (!taskPrompt) {
+    return { ok: false, error: 'Error: schedules require a taskPrompt, command, or action/path payload.' }
+  }
+  normalized.taskPrompt = taskPrompt
+
+  const validationError = validateScheduleArtifacts(normalized, baseDir)
+  if (validationError) return { ok: false, error: `Error: ${validationError}` }
+
+  if (normalized.nextRunAt == null) {
+    if (normalized.scheduleType === 'once') {
+      const runAt = normalizePositiveInt(normalized.runAt)
+      if (runAt != null) normalized.nextRunAt = runAt
+    } else if (normalized.scheduleType === 'interval') {
+      const intervalMs = normalizePositiveInt(normalized.intervalMs)
+      if (intervalMs != null) normalized.nextRunAt = now + intervalMs
+    }
+  }
+
+  return { ok: true, value: normalized }
+}
+
+export function extractScheduleCommandScriptPath(command: string): string | null {
+  return extractScriptPathFromCommand(command)
+}

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

@@ -22,6 +22,18 @@ describe('browser workflow surface', () => {
       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', () => {
@@ -40,6 +52,17 @@ describe('durable wait surface', () => {
   })
 })
 
+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')

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

@@ -30,6 +30,7 @@ import {
   validateManagedAgentAssignment,
 } from '@/lib/server/agent-assignment'
 import { normalizeTaskQualityGate } from '@/lib/server/task-quality-gate'
+import { normalizeSchedulePayload } from '@/lib/server/schedule-normalization'
 import type { ToolBuildContext } from './context'
 import { safePath, findBinaryOnPath } from './context'
 import { normalizeToolInputArgs } from './normalize-tool-args'
@@ -261,6 +262,9 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
     if (!hasPlugin(toolKey)) continue
 
     let description = `Manage SwarmClaw ${res.label}. ${res.readOnly ? 'List and get only.' : 'List, get, create, update, or delete.'} Returns JSON.`
+    if (toolKey.startsWith('manage_') && toolKey !== 'manage_platform') {
+      description += `\n\nUse this direct tool name exactly as shown (\`${toolKey}\`). Do not swap it for \`manage_platform\` unless that umbrella tool is separately enabled in the current session.`
+    }
     if (toolKey === 'manage_tasks') {
       if (assignScope === 'self') {
         description += `\n\nYou may create tasks for yourself ("${ctx?.agentId || 'unknown'}") or leave them unassigned to track multi-step work. You cannot assign tasks to other agents unless a user enables "Assign to Other Agents" in your agent settings. Valid manual statuses: backlog, queued, completed, failed, archived. "running" is runtime-only and set automatically when execution starts.`
@@ -271,9 +275,9 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
       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.`
     } else if (toolKey === 'manage_schedules') {
       if (assignScope === 'self') {
-        description += `\n\nSet "agentId" to assign a schedule to yourself ("${ctx?.agentId || 'unknown'}") or leave it null. You can only assign schedules to yourself. Schedule types: interval (set intervalMs), cron (set cron), once (set runAt). Set taskPrompt for what the agent should do. Before create, call list/get to avoid duplicate schedules. If an equivalent active/paused schedule already exists, create returns that existing schedule (deduplicated=true).`
+        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. If an equivalent active/paused schedule already exists, create returns that existing schedule (deduplicated=true).`
       } else {
-        description += `\n\nSet "agentId" to assign a schedule to an agent (including yourself: "${ctx?.agentId || 'unknown'}"). Schedule types: interval (set intervalMs), cron (set cron), once (set runAt). Set taskPrompt for what the agent should do. Before create, call list/get to avoid duplicate schedules. If an equivalent active/paused schedule already exists, create returns that existing schedule (deduplicated=true).` + agentSummary
+        description += `\n\nOmit "agentId" to assign a schedule to yourself ("${ctx?.agentId || 'unknown'}"), or set "agentId" to another agent when needed. 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. If an equivalent active/paused schedule already exists, create returns that existing schedule (deduplicated=true).` + agentSummary
       }
     } 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.'
@@ -350,7 +354,9 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
                 const resolution = resolveManagedAgentAssignment(
                   parsed as Record<string, unknown>,
                   agents,
-                  toolKey === 'manage_tasks' ? (parsed.agentId || ctx?.agentId || null) : null,
+                  toolKey === 'manage_tasks' || toolKey === 'manage_schedules'
+                    ? (parsed.agentId || ctx?.agentId || null)
+                    : null,
                   { allowDescription: toolKey === 'manage_tasks' },
                 )
                 const assignmentError = validateManagedAgentAssignment({
@@ -369,6 +375,12 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
                 parsed.agentId = resolution.agentId
               }
               if (toolKey === 'manage_schedules') {
+                const normalizedSchedule = normalizeSchedulePayload(parsed as Record<string, unknown>, {
+                  cwd,
+                  now,
+                })
+                if (!normalizedSchedule.ok) return normalizedSchedule.error
+                Object.assign(parsed, normalizedSchedule.value)
                 const duplicate = findDuplicateSchedule(all as Record<string, ScheduleLike>, {
                   agentId: parsed.agentId || null,
                   taskPrompt: parsed.taskPrompt || '',
@@ -552,6 +564,18 @@ export function buildCrudTools(bctx: ToolBuildContext): StructuredToolInterface[
                 }
               }
               all[id] = { ...all[id], ...parsed, updatedAt: Date.now() }
+              if (toolKey === 'manage_schedules') {
+                const normalizedSchedule = normalizeSchedulePayload(all[id] as Record<string, unknown>, {
+                  cwd,
+                  now: Date.now(),
+                })
+                if (!normalizedSchedule.ok) return normalizedSchedule.error
+                all[id] = {
+                  ...all[id],
+                  ...normalizedSchedule.value,
+                  updatedAt: Date.now(),
+                }
+              }
               if (toolKey === 'manage_secrets') {
                 if (!canAccessSecret(all[id])) return 'Error: you do not have access to this secret.'
                 const nextScope = parsed.scope === 'agent'

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

@@ -0,0 +1,170 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { spawnSync } from 'node:child_process'
+import { describe, it } from 'node:test'
+
+const repoRoot = path.resolve(path.dirname(new URL(import.meta.url).pathname), '../../../..')
+
+function runWithTempDataDir(script: string) {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'swarmclaw-discovery-approval-'))
+  try {
+    const result = spawnSync(process.execPath, ['--import', 'tsx', '--input-type=module', '--eval', script], {
+      cwd: repoRoot,
+      env: {
+        ...process.env,
+        DATA_DIR: path.join(tempDir, 'data'),
+        WORKSPACE_DIR: path.join(tempDir, 'workspace'),
+      },
+      encoding: 'utf-8',
+    })
+    assert.equal(result.status, 0, result.stderr || result.stdout || 'subprocess failed')
+    const lines = (result.stdout || '')
+      .trim()
+      .split('\n')
+      .map((line) => line.trim())
+      .filter(Boolean)
+    const jsonLine = [...lines].reverse().find((line) => line.startsWith('{'))
+    return JSON.parse(jsonLine || '{}')
+  } finally {
+    fs.rmSync(tempDir, { recursive: true, force: true })
+  }
+}
+
+describe('discovery approval flows', () => {
+  it('request_tool_access creates a real approval and grants the tool when auto-approved', () => {
+    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
+
+      storage.saveSettings({ approvalsEnabled: false })
+
+      const now = Date.now()
+      storage.saveSessions({
+        session_tools: {
+          id: 'session_tools',
+          name: 'Tool Access 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: [],
+        },
+      })
+
+      const built = await toolsApi.buildSessionTools(process.env.WORKSPACE_DIR, [], {
+        sessionId: 'session_tools',
+        agentId: 'default',
+        platformAssignScope: 'self',
+      })
+      const tool = built.tools.find((entry) => entry.name === 'request_tool_access')
+      const raw = await tool.invoke({ toolId: 'shell', reason: 'Need terminal access.' })
+      const approvals = storage.loadApprovals()
+      const session = storage.loadSessions().session_tools
+      console.log(JSON.stringify({
+        raw,
+        approvalCount: Object.keys(approvals).length,
+        plugins: session.plugins || [],
+      }))
+    `)
+
+    assert.match(String(output.raw), /auto-approved|granted/i)
+    assert.equal(output.approvalCount, 1)
+    assert.equal(output.plugins.includes('shell'), true)
+  })
+
+  it('manage_capabilities request_access accepts query aliases for pluginId', () => {
+    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
+
+      storage.saveSettings({ approvalsEnabled: false })
+
+      const now = Date.now()
+      storage.saveSessions({
+        session_caps: {
+          id: 'session_caps',
+          name: 'Capabilities 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: [],
+        },
+      })
+
+      const built = await toolsApi.buildSessionTools(process.env.WORKSPACE_DIR, [], {
+        sessionId: 'session_caps',
+        agentId: 'default',
+        platformAssignScope: 'self',
+      })
+      const tool = built.tools.find((entry) => entry.name === 'manage_capabilities')
+      const raw = await tool.invoke({ action: 'request_access', query: 'shell', reason: 'Need terminal access.' })
+      const session = storage.loadSessions().session_caps
+      console.log(JSON.stringify({
+        raw,
+        plugins: session.plugins || [],
+      }))
+    `)
+
+    assert.match(String(output.raw), /auto-approved|granted/i)
+    assert.equal(output.plugins.includes('shell'), true)
+  })
+
+  it('granting manage_schedules does not surface the manage_platform umbrella tool', () => {
+    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_sched: {
+          id: 'session_sched',
+          name: 'Schedule Tool Isolation',
+          cwd: process.env.WORKSPACE_DIR,
+          user: 'tester',
+          provider: 'openai',
+          model: 'gpt-test',
+          claudeSessionId: null,
+          messages: [],
+          createdAt: now,
+          lastActiveAt: now,
+          sessionType: 'human',
+          agentId: 'default',
+          plugins: ['manage_schedules'],
+        },
+      })
+
+      const built = await toolsApi.buildSessionTools(process.env.WORKSPACE_DIR, ['manage_schedules'], {
+        sessionId: 'session_sched',
+        agentId: 'default',
+        platformAssignScope: 'self',
+      })
+      console.log(JSON.stringify({
+        toolNames: built.tools.map((entry) => entry.name).sort(),
+      }))
+    `)
+
+    assert.equal(output.toolNames.includes('manage_schedules'), true)
+    assert.equal(output.toolNames.includes('manage_platform'), false)
+  })
+})

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

@@ -15,15 +15,24 @@ async function executeDiscoveryAction(args: Record<string, unknown>, bctx?: Tool
   const normalized = normalizeToolInputArgs(args)
   const action = normalized.action
   const approved = normalized.approved
-  const pluginId = typeof normalized.pluginId === 'string'
+  const explicitPluginId = typeof normalized.pluginId === 'string'
     ? normalized.pluginId.trim()
     : typeof normalized.plugin_id === 'string'
       ? normalized.plugin_id.trim()
-      : undefined
+      : typeof normalized.toolId === 'string'
+        ? normalized.toolId.trim()
+        : typeof normalized.tool_id === 'string'
+          ? normalized.tool_id.trim()
+          : typeof normalized.tool === 'string'
+            ? normalized.tool.trim()
+            : typeof normalized.name === 'string'
+              ? normalized.name.trim()
+              : undefined
   const url = typeof normalized.url === 'string' ? normalized.url.trim() : undefined
   const reason = normalized.reason as string | undefined
   const manager = getPluginManager()
   const q = typeof normalized.query === 'string' ? normalized.query : ''
+  const pluginId = explicitPluginId || (action === 'request_access' ? q.trim() : '')
 
   console.log('[discovery] Executing action:', action, { query: q, pluginId })
 
@@ -88,7 +97,8 @@ async function executeDiscoveryAction(args: Record<string, unknown>, bctx?: Tool
         if (bctx?.ctx?.sessionId) {
           const allSessions = loadSessions()
           const currentSession = allSessions[bctx.ctx.sessionId]
-          if (currentSession && pluginIdMatches(currentSession.tools, pluginId)) {
+          const grantedTools = currentSession?.plugins || currentSession?.tools || []
+          if (currentSession && pluginIdMatches(grantedTools, pluginId)) {
             return JSON.stringify({
               alreadyGranted: true,
               pluginId,
@@ -176,13 +186,13 @@ const DiscoveryPlugin: Plugin = {
   tools: [
     {
       name: 'manage_capabilities',
-      description: 'Search for available plugins locally or in external marketplaces.',
+      description: 'Discover currently available tools, search marketplaces, or request access to a direct tool/plugin name with action="request_access" (for example "shell", "manage_schedules", or "delegate").',
       parameters: {
         type: 'object',
         properties: {
           action: { type: 'string', enum: ['discover', 'search_marketplace', 'request_access', 'install_request'] },
-          query: { type: 'string', description: 'Search term for marketplace' },
-          pluginId: { type: 'string', description: 'The ID or filename of the plugin' },
+          query: { type: 'string', description: 'Search term for marketplace, or the direct tool/plugin name for request_access' },
+          pluginId: { type: 'string', description: 'The exact tool/plugin name to request, such as "shell" or "manage_schedules"' },
           url: { type: 'string', description: 'URL for new plugin install request' },
           reason: { type: 'string', description: 'Why you need this capability' }
         },
@@ -205,8 +215,8 @@ export function buildDiscoveryTools(bctx: ToolBuildContext): StructuredToolInter
         description: DiscoveryPlugin.tools![0].description,
         schema: z.object({
           action: z.enum(['discover', 'search_marketplace', 'request_access', 'install_request']).describe('The discovery action to perform'),
-          query: z.string().optional().describe('The search query for marketplace actions'),
-          pluginId: z.string().optional(),
+          query: z.string().optional().describe('The marketplace query, or the direct tool/plugin name to request access to'),
+          pluginId: z.string().optional().describe('The exact tool/plugin name to request, such as "shell" or "manage_schedules"'),
           url: z.string().optional(),
           reason: z.string().describe('Why you need to perform this discovery action')
         })

package/src/lib/server/session-tools/file-normalize.test.ts

@@ -38,6 +38,11 @@ describe('normalizeFileArgs', () => {
     assert.equal(out.dirPath, 'docs')
   })
 
+  it('defaults empty file payloads to a workspace listing instead of an unknown action', () => {
+    const out = normalizeFileArgs({})
+    assert.equal(out.action, 'list')
+  })
+
   it('infers write from bulk file entries with text content', () => {
     const out = normalizeFileArgs({
       files: [