vellum 0.2.13 → 0.3.2

package/src/tools/terminal/safe-env.ts

@@ -1,37 +0,0 @@
-/**
- * Environment variables that are safe to pass through to child processes.
- * Everything else (API keys, tokens, credentials) is stripped to prevent
- * accidental leakage via agent-spawned commands.
- *
- * Shared by the sandbox bash tool and the evaluate_typescript_code tool.
- */
-const SAFE_ENV_VARS = [
-  'PATH',
-  'HOME',
-  'TERM',
-  'LANG',
-  'EDITOR',
-  'SHELL',
-  'USER',
-  'TMPDIR',
-  'LC_ALL',
-  'LC_CTYPE',
-  'XDG_RUNTIME_DIR',
-  'DISPLAY',
-  'COLORTERM',
-  'TERM_PROGRAM',
-  'SSH_AUTH_SOCK',
-  'SSH_AGENT_PID',
-  'GPG_TTY',
-  'GNUPGHOME',
-] as const;
-
-export function buildSanitizedEnv(): Record<string, string> {
-  const env: Record<string, string> = {};
-  for (const key of SAFE_ENV_VARS) {
-    if (process.env[key] != null) {
-      env[key] = process.env[key]!;
-    }
-  }
-  return env;
-}

package/src/tools/terminal/sandbox-diagnostics.ts

@@ -1,149 +0,0 @@
-import { execSync, execFileSync } from 'node:child_process';
-import { isMacOS, isLinux, getSandboxWorkingDir } from '../../util/platform.js';
-import { getConfig } from '../../config/loader.js';
-import type { SandboxConfig } from '../../config/schema.js';
-import { DEFAULT_SANDBOX_IMAGE } from './backends/docker.js';
-
-export interface SandboxCheckResult {
-  label: string;
-  ok: boolean;
-  detail?: string;
-}
-
-export interface SandboxDiagnostics {
-  config: {
-    enabled: boolean;
-    backend: string;
-    dockerImage: string;
-  };
-  /** Why the active backend was selected (config vs platform default). */
-  activeBackendReason: string;
-  checks: SandboxCheckResult[];
-}
-
-function checkDockerCli(): SandboxCheckResult {
-  try {
-    const out = execSync('docker --version', { stdio: 'pipe', timeout: 5000, encoding: 'utf-8' }).trim();
-    return { label: 'Docker CLI installed', ok: true, detail: out };
-  } catch {
-    return { label: 'Docker CLI installed', ok: false, detail: 'docker not found in PATH' };
-  }
-}
-
-function checkDockerDaemon(): SandboxCheckResult {
-  try {
-    execSync('docker info', { stdio: 'pipe', timeout: 10000 });
-    return { label: 'Docker daemon running', ok: true };
-  } catch {
-    return { label: 'Docker daemon running', ok: false, detail: 'daemon not reachable — start Docker Desktop or run "sudo systemctl start docker"' };
-  }
-}
-
-function checkDockerImage(image: string): SandboxCheckResult {
-  try {
-    execFileSync('docker', ['image', 'inspect', image], { stdio: 'pipe', timeout: 10000 });
-    return { label: `Docker image available (${image})`, ok: true };
-  } catch {
-    // The default sandbox image is built locally from Dockerfile.sandbox — docker pull won't work.
-    const remediation = image === DEFAULT_SANDBOX_IMAGE
-      ? 'build with: docker build --no-cache -t vellum-sandbox:latest -f assistant/Dockerfile.sandbox assistant'
-      : `pull with: docker pull ${image}`;
-    return { label: `Docker image available (${image})`, ok: false, detail: remediation };
-  }
-}
-
-function checkDockerMountProbe(image: string): SandboxCheckResult {
-  // Use the same sandbox path and writable-mount probe that the runtime
-  // preflight uses (checkMountProbe in docker.ts) so doctor validates
-  // exactly what runtime enforces.
-  const sandboxRoot = getSandboxWorkingDir();
-  try {
-    execFileSync(
-      'docker',
-      [
-        'run', '--rm',
-        '--mount', `type=bind,src=${sandboxRoot},dst=/workspace`,
-        image, 'test', '-w', '/workspace',
-      ],
-      { stdio: 'pipe', timeout: 15000 },
-    );
-    return { label: 'Docker mount writable', ok: true };
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : 'unknown error';
-    return {
-      label: 'Docker mount writable',
-      ok: false,
-      detail: 'Cannot bind-mount sandbox root or /workspace is not writable. ' +
-        'If using Docker Desktop, enable file sharing for this path in Settings > Resources > File Sharing. ' +
-        `(${msg})`,
-    };
-  }
-}
-
-function checkNativeBackend(): SandboxCheckResult {
-  if (isMacOS()) {
-    try {
-      execSync('sandbox-exec -n no-network true', { stdio: 'pipe', timeout: 5000 });
-      return { label: 'Native sandbox (macOS sandbox-exec)', ok: true };
-    } catch {
-      return { label: 'Native sandbox (macOS sandbox-exec)', ok: false, detail: 'sandbox-exec not functional' };
-    }
-  }
-  if (isLinux()) {
-    try {
-      execSync('bwrap --ro-bind / / --unshare-net --unshare-pid true', { stdio: 'pipe', timeout: 5000 });
-      return { label: 'Native sandbox (Linux bwrap)', ok: true };
-    } catch {
-      return { label: 'Native sandbox (Linux bwrap)', ok: false, detail: 'bwrap not available — install bubblewrap' };
-    }
-  }
-  return { label: 'Native sandbox', ok: false, detail: `not supported on ${process.platform}` };
-}
-
-function getActiveBackendReason(sandboxConfig: SandboxConfig): string {
-  if (!sandboxConfig.enabled) {
-    return 'Sandbox is disabled in configuration';
-  }
-  if (sandboxConfig.backend === 'docker') {
-    return 'Docker backend selected in configuration (sandbox.backend = "docker")';
-  }
-  return 'Native backend selected in configuration (sandbox.backend = "native")';
-}
-
-/**
- * Run sandbox backend diagnostics. Checks Docker availability,
- * native backend availability, and reports current configuration.
- */
-export function runSandboxDiagnostics(): SandboxDiagnostics {
-  const config = getConfig();
-  const sandboxConfig = config.sandbox;
-
-  const checks: SandboxCheckResult[] = [];
-
-  // Always check native backend availability as a diagnostic signal
-  checks.push(checkNativeBackend());
-
-  // Docker checks: CLI, daemon, image, container execution
-  const cliResult = checkDockerCli();
-  checks.push(cliResult);
-
-  if (cliResult.ok) {
-    const daemonResult = checkDockerDaemon();
-    checks.push(daemonResult);
-
-    if (daemonResult.ok) {
-      checks.push(checkDockerImage(sandboxConfig.docker.image));
-      checks.push(checkDockerMountProbe(sandboxConfig.docker.image));
-    }
-  }
-
-  return {
-    config: {
-      enabled: sandboxConfig.enabled,
-      backend: sandboxConfig.backend,
-      dockerImage: sandboxConfig.docker.image,
-    },
-    activeBackendReason: getActiveBackendReason(sandboxConfig),
-    checks,
-  };
-}

package/src/tools/terminal/sandbox.ts

@@ -1,44 +0,0 @@
-import { NativeBackend } from './backends/native.js';
-import { DockerBackend } from './backends/docker.js';
-import type { SandboxResult, WrapOptions } from './backends/types.js';
-import type { SandboxConfig } from '../../config/schema.js';
-import { getSandboxWorkingDir } from '../../util/platform.js';
-
-export type { SandboxResult, SandboxBackend, WrapOptions } from './backends/types.js';
-
-const nativeBackend = new NativeBackend();
-
-/**
- * Wrap a shell command for sandboxed execution.
- *
- * When sandboxing is disabled, returns a plain bash invocation.
- * When enabled, delegates to the configured backend (native or docker).
- * Fails closed if the backend cannot be applied.
- *
- * @param options  Per-invocation overrides (e.g. networkMode for proxied bash).
- */
-export function wrapCommand(
-  command: string,
-  workingDir: string,
-  config: SandboxConfig,
-  options?: WrapOptions,
-): SandboxResult {
-  if (!config.enabled) {
-    return {
-      command: 'bash',
-      args: ['-c', '--', command],
-      sandboxed: false,
-    };
-  }
-
-  if (config.backend === 'docker') {
-    // Always mount the canonical sandbox fs root, not whatever workingDir
-    // happens to be. workingDir may be a subdirectory; the mount source
-    // must be the fixed root so the entire sandbox filesystem is available.
-    const sandboxRoot = getSandboxWorkingDir();
-    const backend = new DockerBackend(sandboxRoot, config.docker);
-    return backend.wrap(command, workingDir, options);
-  }
-
-  return nativeBackend.wrap(command, workingDir, options);
-}

package/src/tools/terminal/shell.ts

@@ -1,257 +0,0 @@
-import { spawn, execSync } from 'node:child_process';
-import { platform } from 'node:os';
-import { RiskLevel } from '../../permissions/types.js';
-import type { Tool, ToolContext, ToolExecutionResult } from '../types.js';
-import type { ToolDefinition } from '../../providers/types.js';
-import { registerTool } from '../registry.js';
-import { getConfig } from '../../config/loader.js';
-import { getLogger } from '../../util/logger.js';
-import { redactSecrets } from '../../security/secret-scanner.js';
-import { wrapCommand } from './sandbox.js';
-import { formatShellOutput } from '../shared/shell-output.js';
-import { buildSanitizedEnv } from './safe-env.js';
-import {
-  getOrStartSession,
-  getSessionEnv,
-} from '../network/script-proxy/index.js';
-import { getDataDir } from '../../util/platform.js';
-import { resolveCredentialRef } from '../credentials/resolve.js';
-import { buildCredentialRefTrace } from '../network/script-proxy/logging.js';
-
-const log = getLogger('shell-tool');
-
-/**
- * Returns the host address to bind the proxy to when Docker sandbox is active.
- * On macOS, Docker Desktop routes host.docker.internal through the VM to
- * 127.0.0.1, so no bind change is needed. On Linux, we need to bind to the
- * Docker bridge gateway IP so containers can reach the proxy.
- */
-function getDockerProxyHost(): string {
-  if (platform() !== 'linux') return '127.0.0.1';
-
-  try {
-    // Docker bridge gateway is the default route from inside docker0 network.
-    // `ip -4 addr show docker0` outputs the gateway IP assigned to the bridge.
-    const output = execSync('ip -4 addr show docker0 2>/dev/null', { encoding: 'utf-8' });
-    const match = output.match(/inet\s+(\d+\.\d+\.\d+\.\d+)/);
-    if (match) return match[1];
-  } catch {
-    // docker0 interface may not exist (e.g. rootless Docker, custom networks)
-  }
-  // Fallback: bind to localhost when docker0 is unavailable (e.g. rootless
-  // Docker, custom networks). This avoids EADDRNOTAVAIL from 172.17.0.1 while
-  // keeping the proxy off public interfaces — 0.0.0.0 would expose the
-  // unauthenticated credential proxy to the network. Docker containers won't
-  // be able to reach localhost on the host, but that's a safer failure mode.
-  return '127.0.0.1';
-}
-
-class ShellTool implements Tool {
-  name = 'bash';
-  description = 'Execute a shell command on the local machine';
-  category = 'terminal';
-  defaultRiskLevel = RiskLevel.Medium;
-
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
-        type: 'object',
-        properties: {
-          command: {
-            type: 'string',
-            description: 'The shell command to execute',
-          },
-          reason: {
-            type: 'string',
-            description: 'Brief human-readable explanation of what this command does and why, shown to the user in the permission prompt (e.g. "to find available location services")',
-          },
-          timeout_seconds: {
-            type: 'number',
-            description: 'Optional timeout in seconds. Defaults to the configured default (120s). Cannot exceed the configured maximum.',
-          },
-          network_mode: {
-            type: 'string',
-            enum: ['off', 'proxied'],
-            description: 'Network access mode for the command. "off" (default) blocks network access; "proxied" routes traffic through the credential proxy.',
-          },
-          credential_ids: {
-            type: 'array',
-            items: { type: 'string' },
-            description: 'Optional list of credential IDs to inject via the proxy when network_mode is "proxied".',
-          },
-        },
-        required: ['command', 'reason'],
-      },
-    };
-  }
-
-  async execute(input: Record<string, unknown>, context: ToolContext): Promise<ToolExecutionResult> {
-    const command = input.command as string;
-    if (!command || typeof command !== 'string') {
-      return { content: 'Error: command is required and must be a string', isError: true };
-    }
-
-    // Reject commands containing null bytes — they cause truncation at the
-    // OS level while the parser sees the full string, enabling bypass.
-    if (command.includes('\0')) {
-      return { content: 'Error: command contains null bytes', isError: true };
-    }
-
-    const networkMode: 'off' | 'proxied' =
-      input.network_mode === 'proxied' ? 'proxied' : 'off';
-
-    const rawCredentialRefs: string[] = [];
-    if (Array.isArray(input.credential_ids)) {
-      for (const id of input.credential_ids) {
-        if (typeof id === 'string' && id.length > 0) {
-          rawCredentialRefs.push(id);
-        }
-      }
-    }
-
-    // Resolve credential refs (UUID or service/field) to canonical UUIDs.
-    // Fail fast if any ref is unresolvable — partial execution with missing
-    // credentials is worse than a clear error.
-    const credentialIds: string[] = [];
-    if (networkMode === 'proxied' && rawCredentialRefs.length > 0) {
-      const unresolvedRefs: string[] = [];
-      const seenIds = new Set<string>();
-      for (const ref of rawCredentialRefs) {
-        const resolved = resolveCredentialRef(ref);
-        if (!resolved) {
-          unresolvedRefs.push(ref);
-        } else if (!seenIds.has(resolved.credentialId)) {
-          seenIds.add(resolved.credentialId);
-          credentialIds.push(resolved.credentialId);
-        }
-      }
-      if (unresolvedRefs.length > 0) {
-        log.warn({ trace: buildCredentialRefTrace(rawCredentialRefs, credentialIds, unresolvedRefs) }, 'Credential ref resolution failed');
-        return {
-          content: `Error: unknown credential reference(s): ${unresolvedRefs.join(', ')}. Use credential_store list to see available credentials.`,
-          isError: true,
-        };
-      }
-      log.debug({ trace: buildCredentialRefTrace(rawCredentialRefs, credentialIds, []) }, 'Credential refs resolved');
-    } else {
-      credentialIds.push(...rawCredentialRefs);
-    }
-
-    const config = getConfig();
-    const { shellDefaultTimeoutSec, shellMaxTimeoutSec } = config.timeouts;
-    const requestedSec = typeof input.timeout_seconds === 'number' ? input.timeout_seconds : shellDefaultTimeoutSec;
-    const timeoutSec = Math.max(1, Math.min(requestedSec, shellMaxTimeoutSec));
-    const timeoutMs = timeoutSec * 1000;
-
-    log.info({ command: redactSecrets(command), cwd: context.workingDir, timeoutSec, networkMode, rawRefs: rawCredentialRefs, credentialIds }, 'Executing shell command');
-
-    // Resolve sandbox config early — needed both for proxy env and command wrapping.
-    const sandboxConfig = context.sandboxOverride != null
-      ? { ...config.sandbox, enabled: context.sandboxOverride }
-      : config.sandbox;
-    const isDockerSandbox = sandboxConfig.enabled && sandboxConfig.backend === 'docker';
-
-    // Acquire proxy session if proxied mode is requested.
-    // `getOrStartSession` serializes per-conversation so concurrent proxied
-    // commands share a single session instead of each creating one.
-    // Sessions are NOT stopped here — the session manager's idle timer handles
-    // cleanup after all commands finish (see resetIdleTimer / stopAllSessions).
-    let proxyEnv: import('../network/script-proxy/types.js').ProxyEnvVars | null = null;
-
-    if (networkMode === 'proxied') {
-      try {
-        const { session } = await getOrStartSession(
-          context.conversationId,
-          credentialIds,
-          undefined,
-          getDataDir(),
-          context.proxyApprovalCallback,
-          isDockerSandbox ? { listenHost: getDockerProxyHost() } : undefined,
-        );
-        proxyEnv = getSessionEnv(session.id, { dockerMode: isDockerSandbox });
-      } catch (err) {
-        log.error({ err }, 'Failed to start proxy session');
-        return {
-          content: `Error: failed to start proxy session — ${err instanceof Error ? err.message : String(err)}`,
-          isError: true,
-        };
-      }
-    }
-
-    const env = buildSanitizedEnv();
-    if (proxyEnv) {
-      Object.assign(env, proxyEnv);
-    }
-
-    const result = await new Promise<ToolExecutionResult>((resolve) => {
-      const stdoutChunks: Buffer[] = [];
-      const stderrChunks: Buffer[] = [];
-      let timedOut = false;
-
-      const wrapped = wrapCommand(command, context.workingDir, sandboxConfig, { networkMode });
-      const child = spawn(wrapped.command, wrapped.args, {
-        cwd: context.workingDir,
-        env,
-        stdio: ['ignore', 'pipe', 'pipe'],
-      });
-
-      const timer = setTimeout(() => {
-        timedOut = true;
-        child.kill('SIGKILL');
-      }, timeoutMs);
-
-      // Cooperative cancellation via AbortSignal
-      const onAbort = () => {
-        child.kill('SIGKILL');
-      };
-      if (context.signal) {
-        if (context.signal.aborted) {
-          child.kill('SIGKILL');
-        } else {
-          context.signal.addEventListener('abort', onAbort, { once: true });
-        }
-      }
-
-      child.stdout.on('data', (data: Buffer) => {
-        stdoutChunks.push(data);
-        context.onOutput?.(data.toString());
-      });
-
-      child.stderr.on('data', (data: Buffer) => {
-        stderrChunks.push(data);
-        context.onOutput?.(data.toString());
-      });
-
-      child.on('close', (code) => {
-        clearTimeout(timer);
-        context.signal?.removeEventListener('abort', onAbort);
-
-        const stdout = Buffer.concat(stdoutChunks).toString();
-        const stderr = Buffer.concat(stderrChunks).toString();
-        const fmtResult = formatShellOutput(stdout, stderr, code, timedOut, timeoutSec);
-
-        resolve({
-          content: fmtResult.content,
-          isError: fmtResult.isError,
-          status: fmtResult.status,
-        });
-      });
-
-      child.on('error', (err) => {
-        clearTimeout(timer);
-        context.signal?.removeEventListener('abort', onAbort);
-        resolve({
-          content: `Error spawning command: ${err.message}${(err as NodeJS.ErrnoException).code === 'ENOENT' ? '. The command was not found — check that it is installed and in PATH.' : ''}`,
-          isError: true,
-        });
-      });
-    });
-
-    return result;
-  }
-}
-
-export const shellTool: Tool = new ShellTool();
-registerTool(shellTool);

package/src/tools/tool-manifest.ts

@@ -1,198 +0,0 @@
-/**
- * Declarative tool manifest — single place to inspect what gets registered.
- *
- * Each entry describes HOW a tool (or group of tools) gets loaded and
- * registered.  `initializeTools()` in `registry.ts` iterates this list
- * so adding/removing tools only requires editing this manifest.
- */
-
-import { RiskLevel } from '../permissions/types.js';
-import type { LazyToolDescriptor } from './registry.js';
-import type { Tool } from './types.js';
-import { memorySearchTool, memorySaveTool, memoryUpdateTool } from './memory/register.js';
-import { credentialStoreTool } from './credentials/vault.js';
-import { accountManageTool } from './credentials/account-registry.js';
-import { screenWatchTool } from './watch/screen-watch.js';
-import { vellumSkillsCatalogTool } from './skills/vellum-catalog.js';
-import { cliDiscoverTool } from './host-terminal/cli-discover.js';
-
-// ── Eager side-effect modules ───────────────────────────────────────
-// Importing these modules triggers a top-level `registerTool()` call.
-
-export async function loadEagerModules(): Promise<void> {
-  await import('./filesystem/read.js');
-  await import('./filesystem/write.js');
-  await import('./filesystem/edit.js');
-  await import('./network/web-search.js');
-  await import('./network/web-fetch.js');
-  await import('./skills/load.js');
-  await import('./skills/scaffold-managed.js');
-  await import('./skills/delete-managed.js');
-  await import('./system/request-permission.js');
-  await import('./assets/search.js');
-  await import('./assets/materialize.js');
-  await import('./filesystem/view-image.js');
-  await import('./calls/call-start.js');
-  await import('./calls/call-status.js');
-  await import('./calls/call-end.js');
-  await import('./system/version.js');
-}
-
-// Tool names registered by the eager modules above.  Listed explicitly so
-// initializeTools() can recognise ESM-cached eager-module tools that were
-// already in the registry before init ran (e.g. when a test file imports
-// an eager module at the top level).
-export const eagerModuleToolNames: string[] = [
-  'file_read',
-  'file_write',
-  'file_edit',
-  'web_search',
-  'web_fetch',
-  'skill_load',
-  'scaffold_managed_skill',
-  'delete_managed_skill',
-  'request_system_permission',
-  'asset_search',
-  'asset_materialize',
-  'view_image',
-  'call_start',
-  'call_status',
-  'call_end',
-  'version',
-];
-
-// ── Explicit tool instances ─────────────────────────────────────────
-// Tools exported as instances — registered by initializeTools() without
-// relying on import side effects.
-
-export const explicitTools: Tool[] = [
-  memorySearchTool,
-  memorySaveTool,
-  memoryUpdateTool,
-  credentialStoreTool,
-  accountManageTool,
-  screenWatchTool,
-  vellumSkillsCatalogTool,
-  cliDiscoverTool,
-];
-
-// ── Lazy tool descriptors ───────────────────────────────────────────
-// Tools that defer module loading until first invocation.
-
-export const lazyTools: LazyToolDescriptor[] = [
-  {
-    name: 'evaluate_typescript_code',
-    description: 'Evaluate a TypeScript snippet in an isolated sandbox. Use this to test code before persisting it as a managed skill.',
-    category: 'terminal',
-    defaultRiskLevel: RiskLevel.High,
-    definition: {
-      name: 'evaluate_typescript_code',
-      description: 'Evaluate a TypeScript snippet in an isolated sandbox. Use this to test code before persisting it as a managed skill.',
-      input_schema: {
-        type: 'object',
-        properties: {
-          code: {
-            type: 'string',
-            description: 'The TypeScript source code to evaluate. Must export a `default` or `run` function.',
-          },
-          mock_input_json: {
-            type: 'string',
-            description: 'Optional JSON string to pass as input. Defaults to "{}".',
-          },
-          timeout_seconds: {
-            type: 'number',
-            description: 'Optional timeout in seconds (1-20). Defaults to 10.',
-          },
-          filename: {
-            type: 'string',
-            description: 'Optional filename for the snippet (default: "snippet.ts").',
-          },
-          entrypoint: {
-            type: 'string',
-            enum: ['default', 'run'],
-            description: 'Which export to call: "default" or "run". Defaults to "default".',
-          },
-          max_output_chars: {
-            type: 'number',
-            description: 'Optional max output characters (1-25000). Defaults to 25000.',
-          },
-        },
-        required: ['code'],
-      },
-    },
-    loader: async () => {
-      const mod = await import('./terminal/evaluate-typescript.js');
-      return mod.evaluateTypescriptTool;
-    },
-  },
-  {
-    name: 'bash',
-    description: 'Execute a shell command on the local machine',
-    category: 'terminal',
-    defaultRiskLevel: RiskLevel.Medium,
-    definition: {
-      name: 'bash',
-      description: 'Execute a shell command on the local machine',
-      input_schema: {
-        type: 'object',
-        properties: {
-          command: {
-            type: 'string',
-            description: 'The shell command to execute',
-          },
-          timeout_seconds: {
-            type: 'number',
-            description: 'Optional timeout in seconds. Defaults to the configured default (120s). Cannot exceed the configured maximum.',
-          },
-          network_mode: {
-            type: 'string',
-            enum: ['off', 'proxied'],
-            description: 'Network access mode for the command. "off" (default) blocks network access; "proxied" routes traffic through the credential proxy.',
-          },
-          credential_ids: {
-            type: 'array',
-            items: { type: 'string' },
-            description: 'Optional list of credential IDs to inject via the proxy when network_mode is "proxied".',
-          },
-        },
-        required: ['command'],
-      },
-    },
-    loader: async () => {
-      const mod = await import('./terminal/shell.js');
-      return mod.shellTool;
-    },
-  },
-  {
-    name: 'swarm_delegate',
-    description: 'Decompose a complex task into parallel specialist subtasks and execute them concurrently.',
-    category: 'orchestration',
-    defaultRiskLevel: RiskLevel.Medium,
-    definition: {
-      name: 'swarm_delegate',
-      description: 'Decompose a complex task into parallel specialist subtasks and execute them concurrently. Use this for multi-part tasks that benefit from parallel research, coding, and review.',
-      input_schema: {
-        type: 'object',
-        properties: {
-          objective: {
-            type: 'string',
-            description: 'The complex task to decompose and execute in parallel',
-          },
-          context: {
-            type: 'string',
-            description: 'Optional additional context about the task or codebase',
-          },
-          max_workers: {
-            type: 'number',
-            description: 'Maximum concurrent workers (1-6, default from config)',
-          },
-        },
-        required: ['objective'],
-      },
-    },
-    loader: async () => {
-      const mod = await import('./swarm/delegate.js');
-      return mod.swarmDelegateTool;
-    },
-  },
-];