@opencoven/coven-code 0.0.4 → 0.0.6

package/src/tools/builtin/grep.mjs

@@ -1,82 +0,0 @@
-import { readFileSync } from 'node:fs';
-import path from 'node:path';
-import { resolvePermissionDecision } from '../../commands/permissions.mjs';
-import { runPluginEventHandlers } from '../../plugins/discover.mjs';
-import { walkFiles } from '../../util/glob.mjs';
-import { isToolDisabled } from '../toolbox.mjs';
-import {
-  applyToolCallDecision,
-  createToolUseID,
-  permissionDeniedOutput,
-  pluginTextToolRunResult,
-  pluginToolCallEvent,
-  pluginToolResultEvent,
-  pluginToolUseBlock,
-  relativeToolPath,
-  toolCallDecisionToolRun,
-  validateToolCallDecision,
-} from './runtime.mjs';
-
-export const TOOL_NAME = 'Grep';
-
-export async function executePromptGrepToolRequest(request, parsed = {}, plugins = { handlers: {} }, threadId = '') {
-  if (isToolDisabled(TOOL_NAME, 'built-in', parsed)) return { output: `Tool disabled: ${TOOL_NAME}` };
-  request = { ...request, flags: normalizeGrepInput(request.flags) };
-  if (!request.flags.pattern) return { output: 'Grep requires --pattern' };
-  const toolUseID = createToolUseID();
-  const callDecision = await runPluginEventHandlers(
-    plugins.handlers['tool.call'],
-    pluginToolCallEvent(TOOL_NAME, request.flags, threadId, toolUseID),
-    validateToolCallDecision,
-  );
-  const callResult = applyToolCallDecision(TOOL_NAME, request, callDecision);
-  if (callResult.output) return toolCallDecisionToolRun(TOOL_NAME, request.flags, toolUseID, callResult);
-  request = { ...callResult.request, flags: normalizeGrepInput(callResult.request.flags) };
-  const decision = resolvePermissionDecision(TOOL_NAME, request.flags, parsed, { threadId });
-  if (!parsed.dangerouslyAllowAll && decision.action !== 'allow') {
-    return {
-      output: permissionDeniedOutput(TOOL_NAME, decision),
-      permissionDenials: [{ tool: TOOL_NAME, action: decision.action, reason: 'permission' }],
-    };
-  }
-  const output = grepBuiltinFiles(request.flags.pattern, request.flags.path);
-  const resultDecision = await runPluginEventHandlers(
-    plugins.handlers['tool.result'],
-    pluginToolResultEvent(TOOL_NAME, request.flags, 'done', output, threadId, toolUseID),
-  );
-  return {
-    ...pluginTextToolRunResult(resultDecision, output),
-    toolUse: pluginToolUseBlock(TOOL_NAME, request.flags, toolUseID),
-  };
-}
-
-function normalizeGrepInput(input = {}) {
-  const pattern = input.pattern ?? input.regex ?? input.query;
-  const searchPath = input.path ?? input.dir ?? input.cwd ?? '.';
-  return {
-    ...input,
-    pattern: pattern ? String(pattern) : '',
-    path: searchPath ? String(searchPath) : '.',
-  };
-}
-
-function grepBuiltinFiles(pattern, searchPath = '.') {
-  const root = path.isAbsolute(searchPath) ? searchPath : path.resolve(process.cwd(), searchPath);
-  const files = walkFiles(root).sort();
-  const re = new RegExp(pattern);
-  const matches = [];
-  for (const filePath of files) {
-    let content = '';
-    try {
-      content = readFileSync(filePath, 'utf8');
-    } catch {
-      continue;
-    }
-    const lines = content.split(/\r?\n/);
-    for (let index = 0; index < lines.length; index += 1) {
-      if (!re.test(lines[index])) continue;
-      matches.push(`${relativeToolPath(filePath)}:${index + 1}:${lines[index]}`);
-    }
-  }
-  return matches.join('\n');
-}

package/src/tools/builtin/index.mjs

@@ -1,83 +0,0 @@
-import { loadPlugins } from '../../plugins/discover.mjs';
-import { parseToolUseArgs } from '../toolbox.mjs';
-import { splitShellWords } from '../../util/shell.mjs';
-import { executePromptBashToolRequest } from './bash.mjs';
-import { executePromptCreateFileToolRequest } from './create-file.mjs';
-import { executePromptEditFileToolRequest } from './edit-file.mjs';
-import { executePromptFinderToolRequest } from './finder.mjs';
-import { executePromptGlobToolRequest } from './glob.mjs';
-import { executePromptGrepToolRequest } from './grep.mjs';
-import { executePromptLibrarianToolRequest } from './librarian.mjs';
-import { executePromptLookAtToolRequest } from './look-at.mjs';
-import { executePromptMcpToolRequest } from './mcp.mjs';
-import { executePromptMermaidToolRequest } from './mermaid.mjs';
-import { executePromptOracleToolRequest } from './oracle.mjs';
-import { executePromptPainterToolRequest } from './painter.mjs';
-import { executePromptPluginToolRequest } from './plugin-tool.mjs';
-import { executePromptReadMcpResourceToolRequest } from './read-mcp-resource.mjs';
-import { executePromptReadToolRequest } from './read.mjs';
-import { executePromptReadWebPageToolRequest } from './read-web-page.mjs';
-import { executePromptTaskToolRequest } from './task.mjs';
-import { executePromptToolboxToolRequest } from './toolbox-tool.mjs';
-import { executePromptUndoEditToolRequest } from './undo-edit.mjs';
-import { executePromptWebSearchToolRequest } from './web-search.mjs';
-
-const BUILTIN_DISPATCH = new Map([
-  ['Bash', (request, stdin, parsed, plugins, threadId) =>
-    executePromptBashToolRequest(request, stdin, parsed, plugins, threadId)],
-  ['Read', (request, _stdin, parsed, plugins, threadId) =>
-    executePromptReadToolRequest(request, parsed, plugins, threadId)],
-  ['Grep', (request, _stdin, parsed, plugins, threadId) =>
-    executePromptGrepToolRequest(request, parsed, plugins, threadId)],
-  ['glob', (request, _stdin, parsed, plugins, threadId) =>
-    executePromptGlobToolRequest(request, parsed, plugins, threadId)],
-  ['create_file', (request, _stdin, parsed, plugins, threadId) =>
-    executePromptCreateFileToolRequest(request, parsed, plugins, threadId)],
-  ['edit_file', (request, _stdin, parsed, plugins, threadId) =>
-    executePromptEditFileToolRequest(request, parsed, plugins, threadId)],
-  ['undo_edit', (request, _stdin, parsed, plugins, threadId) =>
-    executePromptUndoEditToolRequest(request, parsed, plugins, threadId)],
-  ['Task', (request, _stdin, parsed, plugins, threadId) =>
-    executePromptTaskToolRequest(request, parsed, plugins, threadId)],
-  ['oracle', (request, _stdin, parsed, plugins, threadId) =>
-    executePromptOracleToolRequest(request, parsed, plugins, threadId)],
-  ['librarian', (request, _stdin, parsed, plugins, threadId) =>
-    executePromptLibrarianToolRequest(request, parsed, plugins, threadId)],
-  ['painter', (request, _stdin, parsed, plugins, threadId) =>
-    executePromptPainterToolRequest(request, parsed, plugins, threadId)],
-  ['mermaid', (request, _stdin, parsed, plugins, threadId) =>
-    executePromptMermaidToolRequest(request, parsed, plugins, threadId)],
-  ['look_at', (request, _stdin, parsed, plugins, threadId) =>
-    executePromptLookAtToolRequest(request, parsed, plugins, threadId)],
-  ['web_search', (request, _stdin, parsed, plugins, threadId) =>
-    executePromptWebSearchToolRequest(request, parsed, plugins, threadId)],
-  ['read_web_page', (request, _stdin, parsed, plugins, threadId) =>
-    executePromptReadWebPageToolRequest(request, parsed, plugins, threadId)],
-  ['find_thread', (request, _stdin, parsed, plugins, threadId) =>
-    executePromptFinderToolRequest(request, parsed, plugins, threadId, 'find_thread')],
-  ['finder', (request, _stdin, parsed, plugins, threadId) =>
-    executePromptFinderToolRequest(request, parsed, plugins, threadId)],
-  ['read_mcp_resource', (request, _stdin, parsed, plugins, threadId) =>
-    executePromptReadMcpResourceToolRequest(request, parsed, plugins, threadId)],
-]);
-
-export async function executePromptToolRequest(prompt, stdin, threadId, parsed = {}, plugins) {
-  const request = parsePromptToolRequest(prompt);
-  if (!request) return undefined;
-  const resolvedPlugins = plugins ?? await loadPlugins(process.cwd());
-  if (request.toolName.startsWith('mcp__')) {
-    return executePromptMcpToolRequest(request, parsed, threadId, resolvedPlugins);
-  }
-  const builtin = BUILTIN_DISPATCH.get(request.toolName);
-  if (builtin) return builtin(request, stdin, parsed, resolvedPlugins, threadId);
-  const pluginTool = resolvedPlugins.tools.find((entry) => entry.name === request.toolName);
-  if (pluginTool) return executePromptPluginToolRequest(pluginTool, request, parsed, resolvedPlugins, threadId);
-  return executePromptToolboxToolRequest(request, stdin, parsed, resolvedPlugins, threadId);
-}
-
-export function parsePromptToolRequest(prompt) {
-  const match = prompt.match(/\b(?:use|run|call)\s+([A-Za-z0-9_-]+(?:__[A-Za-z0-9_-]+)?)([^\r\n]*)/i);
-  if (!match) return undefined;
-  const useArgs = parseToolUseArgs([match[1], ...splitShellWords(match[2] ?? '')]);
-  return { toolName: useArgs.toolName, flags: useArgs.flags };
-}

package/src/tools/builtin/librarian.mjs

@@ -1,97 +0,0 @@
-import { readFileSync } from 'node:fs';
-import path from 'node:path';
-import { resolvePermissionDecision } from '../../commands/permissions.mjs';
-import { runPluginEventHandlers } from '../../plugins/discover.mjs';
-import { walkFiles } from '../../util/glob.mjs';
-import { isToolDisabled } from '../toolbox.mjs';
-import {
-  applyToolCallDecision,
-  createToolUseID,
-  permissionDeniedOutput,
-  pluginTextToolRunResult,
-  pluginToolCallEvent,
-  pluginToolResultEvent,
-  pluginToolUseBlock,
-  toolCallDecisionToolRun,
-  validateToolCallDecision,
-} from './runtime.mjs';
-
-export const TOOL_NAME = 'librarian';
-
-export async function executePromptLibrarianToolRequest(request, parsed = {}, plugins = { handlers: {} }, threadId = '') {
-  if (isToolDisabled(TOOL_NAME, 'built-in', parsed)) return { output: `Tool disabled: ${TOOL_NAME}` };
-  request = { ...request, flags: normalizeLibrarianInput(request.flags) };
-  if (!request.flags.query) return { output: 'librarian requires --query' };
-  const toolUseID = createToolUseID();
-  const callDecision = await runPluginEventHandlers(
-    plugins.handlers['tool.call'],
-    pluginToolCallEvent(TOOL_NAME, request.flags, threadId, toolUseID),
-    validateToolCallDecision,
-  );
-  const callResult = applyToolCallDecision(TOOL_NAME, request, callDecision);
-  if (callResult.output) return toolCallDecisionToolRun(TOOL_NAME, request.flags, toolUseID, callResult);
-  request = { ...callResult.request, flags: normalizeLibrarianInput(callResult.request.flags) };
-  const decision = resolvePermissionDecision(TOOL_NAME, request.flags, parsed, { threadId });
-  if (!parsed.dangerouslyAllowAll && decision.action !== 'allow') {
-    return {
-      output: permissionDeniedOutput(TOOL_NAME, decision),
-      permissionDenials: [{ tool: TOOL_NAME, action: decision.action, reason: 'permission' }],
-    };
-  }
-  const output = searchWorkspaceForLibrarian(request.flags);
-  const resultDecision = await runPluginEventHandlers(
-    plugins.handlers['tool.result'],
-    pluginToolResultEvent(TOOL_NAME, request.flags, 'done', output, threadId, toolUseID),
-  );
-  return {
-    ...pluginTextToolRunResult(resultDecision, output),
-    toolUse: pluginToolUseBlock(TOOL_NAME, request.flags, toolUseID),
-  };
-}
-
-function normalizeLibrarianInput(input = {}) {
-  const query = input.query ?? input.q ?? input.prompt ?? input.question ?? input.topic;
-  const limit = Number.parseInt(String(input.limit ?? 5), 10);
-  return {
-    ...input,
-    query: query ? String(query) : '',
-    limit: Number.isFinite(limit) && limit > 0 ? Math.min(limit, 20) : 5,
-  };
-}
-
-function searchWorkspaceForLibrarian(input) {
-  const matches = findWorkspaceTextMatches(input.query, input.limit);
-  return [
-    `Librarian search: ${input.query}`,
-    'scope: current workspace',
-    'matches:',
-    ...(matches.length ? matches.map(formatLibrarianMatch) : ['- no local matches found']),
-  ].join('\n');
-}
-
-function findWorkspaceTextMatches(query, limit) {
-  const needle = query.toLowerCase();
-  const root = process.cwd();
-  return walkFiles(root)
-    .map((filePath) => path.relative(root, filePath))
-    .filter((relativePath) => !relativePath.split(path.sep).some((part) => part === '.git' || part === 'node_modules'))
-    .sort()
-    .flatMap((relativePath) => {
-      let text;
-      try {
-        text = readFileSync(path.join(root, relativePath), 'utf8');
-      } catch {
-        return [];
-      }
-      return text.split(/\r?\n/).flatMap((line, index) => (
-        line.toLowerCase().includes(needle)
-          ? [{ path: relativePath, line: index + 1, text: line.trim() }]
-          : []
-      ));
-    })
-    .slice(0, limit);
-}
-
-function formatLibrarianMatch(match) {
-  return `- ${match.path}:${match.line}: ${match.text}`;
-}

package/src/tools/builtin/look-at.mjs

@@ -1,92 +0,0 @@
-import { readFileSync } from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { resolvePermissionDecision } from '../../commands/permissions.mjs';
-import { runPluginEventHandlers } from '../../plugins/discover.mjs';
-import { detectImageMediaType } from '../../util/media.mjs';
-import { isToolDisabled } from '../toolbox.mjs';
-import {
-  applyToolCallDecision,
-  createToolUseID,
-  permissionDeniedOutput,
-  pluginTextToolRunResult,
-  pluginToolCallEvent,
-  pluginToolResultEvent,
-  pluginToolUseBlock,
-  toolCallDecisionToolRun,
-  validateToolCallDecision,
-} from './runtime.mjs';
-
-export const TOOL_NAME = 'look_at';
-
-export async function executePromptLookAtToolRequest(request, parsed = {}, plugins = { handlers: {} }, threadId = '') {
-  if (isToolDisabled(TOOL_NAME, 'built-in', parsed)) return { output: `Tool disabled: ${TOOL_NAME}` };
-  request = { ...request, flags: normalizeLookAtInput(request.flags) };
-  if (!request.flags.path) return { output: 'look_at requires --path' };
-  const toolUseID = createToolUseID();
-  const callDecision = await runPluginEventHandlers(
-    plugins.handlers['tool.call'],
-    pluginToolCallEvent(TOOL_NAME, request.flags, threadId, toolUseID),
-    validateToolCallDecision,
-  );
-  const callResult = applyToolCallDecision(TOOL_NAME, request, callDecision);
-  if (callResult.output) return toolCallDecisionToolRun(TOOL_NAME, request.flags, toolUseID, callResult);
-  request = { ...callResult.request, flags: normalizeLookAtInput(callResult.request.flags) };
-  const decision = resolvePermissionDecision(TOOL_NAME, request.flags, parsed, { threadId });
-  if (!parsed.dangerouslyAllowAll && decision.action !== 'allow') {
-    return {
-      output: permissionDeniedOutput(TOOL_NAME, decision),
-      permissionDenials: [{ tool: TOOL_NAME, action: decision.action, reason: 'permission' }],
-    };
-  }
-  const output = inspectLookAtMedia(request.flags);
-  const resultDecision = await runPluginEventHandlers(
-    plugins.handlers['tool.result'],
-    pluginToolResultEvent(TOOL_NAME, request.flags, 'done', output, threadId, toolUseID),
-  );
-  return {
-    ...pluginTextToolRunResult(resultDecision, output),
-    toolUse: pluginToolUseBlock(TOOL_NAME, request.flags, toolUseID),
-  };
-}
-
-function normalizeLookAtInput(input = {}) {
-  const source = input.path ?? input.file ?? input.image ?? input.pdf ?? input.url;
-  const goal = input.goal ?? input.prompt ?? input.instructions ?? input.question ?? '';
-  return {
-    ...input,
-    path: source ? String(source) : '',
-    goal: String(goal),
-  };
-}
-
-function inspectLookAtMedia(input) {
-  try {
-    const resolved = resolveLookAtPath(input.path);
-    const raw = readFileSync(resolved);
-    return formatLookAtMediaResult(input.path, raw, input.goal);
-  } catch (error) {
-    return `Unable to look at ${input.path}: ${error.message}`;
-  }
-}
-
-function resolveLookAtPath(source) {
-  if (source.startsWith('file://')) return fileURLToPath(source);
-  return path.resolve(process.cwd(), source);
-}
-
-function formatLookAtMediaResult(source, raw, goal) {
-  return [
-    `Looked at: ${source}`,
-    `media_type: ${detectLookAtMediaType(raw)}`,
-    `bytes: ${raw.length}`,
-    `goal: ${goal || '(none)'}`,
-  ].join('\n');
-}
-
-function detectLookAtMediaType(raw) {
-  const imageType = detectImageMediaType(raw);
-  if (imageType) return imageType;
-  if (raw.subarray(0, 5).toString('ascii') === '%PDF-') return 'application/pdf';
-  return 'application/octet-stream';
-}

package/src/tools/builtin/mcp.mjs

@@ -1,51 +0,0 @@
-import { resolvePermissionDecision } from '../../commands/permissions.mjs';
-import { listConfiguredMcpServers } from '../../mcp/discover.mjs';
-import { callMcpTool, isMcpToolIncluded, parseMcpToolName } from '../../mcp/probe.mjs';
-import { runPluginEventHandlers } from '../../plugins/discover.mjs';
-import { isToolDisabled } from '../toolbox.mjs';
-import {
-  applyToolCallDecision,
-  createToolUseID,
-  permissionDeniedOutput,
-  pluginTextToolRunResult,
-  pluginToolCallEvent,
-  pluginToolResultEvent,
-  pluginToolUseBlock,
-  toolCallDecisionToolRun,
-  validateToolCallDecision,
-} from './runtime.mjs';
-
-export async function executePromptMcpToolRequest(request, parsed = {}, threadId = '', plugins = { handlers: {} }) {
-  const parsedName = parseMcpToolName(request.toolName);
-  if (!parsedName) return { output: `Unknown tool: ${request.toolName}` };
-  if (isToolDisabled(request.toolName, 'local-mcp', parsed)) return { output: `Tool disabled: ${request.toolName}` };
-  const toolUseID = createToolUseID();
-  const callDecision = await runPluginEventHandlers(
-    plugins.handlers['tool.call'],
-    pluginToolCallEvent(request.toolName, request.flags, threadId, toolUseID),
-    validateToolCallDecision,
-  );
-  const callResult = applyToolCallDecision(request.toolName, request, callDecision);
-  if (callResult.output) return toolCallDecisionToolRun(request.toolName, request.flags, toolUseID, callResult);
-  request = callResult.request;
-  const decision = resolvePermissionDecision(request.toolName, request.flags, parsed, { threadId });
-  if (!parsed.dangerouslyAllowAll && decision.action !== 'allow') {
-    return {
-      output: permissionDeniedOutput(request.toolName, decision),
-      permissionDenials: [{ tool: request.toolName, action: decision.action, reason: 'permission' }],
-    };
-  }
-  const server = listConfiguredMcpServers(parsed)
-    .find((entry) => entry.name === parsedName.serverName && entry.status === 'approved');
-  if (!server) return { output: `Unknown MCP server: ${parsedName.serverName}` };
-  if (!isMcpToolIncluded(server.config, parsedName.toolName)) return { output: `Tool not available: ${request.toolName}` };
-  const output = await callMcpTool(server.config, parsedName.toolName, request.flags, server.name);
-  const resultDecision = await runPluginEventHandlers(
-    plugins.handlers['tool.result'],
-    pluginToolResultEvent(request.toolName, request.flags, 'done', output, threadId, toolUseID),
-  );
-  return {
-    ...pluginTextToolRunResult(resultDecision, output),
-    toolUse: pluginToolUseBlock(request.toolName, request.flags, toolUseID),
-  };
-}

package/src/tools/builtin/mermaid.mjs

@@ -1,59 +0,0 @@
-import { resolvePermissionDecision } from '../../commands/permissions.mjs';
-import { runPluginEventHandlers } from '../../plugins/discover.mjs';
-import { isToolDisabled } from '../toolbox.mjs';
-import {
-  applyToolCallDecision,
-  createToolUseID,
-  permissionDeniedOutput,
-  pluginTextToolRunResult,
-  pluginToolCallEvent,
-  pluginToolResultEvent,
-  pluginToolUseBlock,
-  toolCallDecisionToolRun,
-  validateToolCallDecision,
-} from './runtime.mjs';
-
-export const TOOL_NAME = 'mermaid';
-
-export async function executePromptMermaidToolRequest(request, parsed = {}, plugins = { handlers: {} }, threadId = '') {
-  if (isToolDisabled(TOOL_NAME, 'built-in', parsed)) return { output: `Tool disabled: ${TOOL_NAME}` };
-  request = { ...request, flags: normalizeMermaidInput(request.flags) };
-  if (!request.flags.code) return { output: 'mermaid requires --code' };
-  const toolUseID = createToolUseID();
-  const callDecision = await runPluginEventHandlers(
-    plugins.handlers['tool.call'],
-    pluginToolCallEvent(TOOL_NAME, request.flags, threadId, toolUseID),
-    validateToolCallDecision,
-  );
-  const callResult = applyToolCallDecision(TOOL_NAME, request, callDecision);
-  if (callResult.output) return toolCallDecisionToolRun(TOOL_NAME, request.flags, toolUseID, callResult);
-  request = { ...callResult.request, flags: normalizeMermaidInput(callResult.request.flags) };
-  const decision = resolvePermissionDecision(TOOL_NAME, request.flags, parsed, { threadId });
-  if (!parsed.dangerouslyAllowAll && decision.action !== 'allow') {
-    return {
-      output: permissionDeniedOutput(TOOL_NAME, decision),
-      permissionDenials: [{ tool: TOOL_NAME, action: decision.action, reason: 'permission' }],
-    };
-  }
-  const output = mermaidOutput(request.flags.code);
-  const resultDecision = await runPluginEventHandlers(
-    plugins.handlers['tool.result'],
-    pluginToolResultEvent(TOOL_NAME, request.flags, 'done', output, threadId, toolUseID),
-  );
-  return {
-    ...pluginTextToolRunResult(resultDecision, output),
-    toolUse: pluginToolUseBlock(TOOL_NAME, request.flags, toolUseID),
-  };
-}
-
-function normalizeMermaidInput(input = {}) {
-  const code = input.code ?? input.diagram ?? input.mermaid ?? input.source;
-  return {
-    ...input,
-    code: code ? String(code) : '',
-  };
-}
-
-function mermaidOutput(code) {
-  return `\`\`\`mermaid\n${String(code).trim()}\n\`\`\``;
-}

package/src/tools/builtin/oracle.mjs

@@ -1,56 +0,0 @@
-import { fixtureAgentResponse } from '../../agent/fixture.mjs';
-import { resolvePermissionDecision } from '../../commands/permissions.mjs';
-import { runPluginEventHandlers } from '../../plugins/discover.mjs';
-import { isToolDisabled } from '../toolbox.mjs';
-import {
-  applyToolCallDecision,
-  createToolUseID,
-  permissionDeniedOutput,
-  pluginTextToolRunResult,
-  pluginToolCallEvent,
-  pluginToolResultEvent,
-  pluginToolUseBlock,
-  toolCallDecisionToolRun,
-  validateToolCallDecision,
-} from './runtime.mjs';
-
-export const TOOL_NAME = 'oracle';
-
-export async function executePromptOracleToolRequest(request, parsed = {}, plugins = { handlers: {} }, threadId = '') {
-  if (isToolDisabled(TOOL_NAME, 'built-in', parsed)) return { output: `Tool disabled: ${TOOL_NAME}` };
-  request = { ...request, flags: normalizeOracleInput(request.flags) };
-  if (!request.flags.prompt) return { output: 'oracle requires --prompt' };
-  const toolUseID = createToolUseID();
-  const callDecision = await runPluginEventHandlers(
-    plugins.handlers['tool.call'],
-    pluginToolCallEvent(TOOL_NAME, request.flags, threadId, toolUseID),
-    validateToolCallDecision,
-  );
-  const callResult = applyToolCallDecision(TOOL_NAME, request, callDecision);
-  if (callResult.output) return toolCallDecisionToolRun(TOOL_NAME, request.flags, toolUseID, callResult);
-  request = { ...callResult.request, flags: normalizeOracleInput(callResult.request.flags) };
-  const decision = resolvePermissionDecision(TOOL_NAME, request.flags, parsed, { threadId });
-  if (!parsed.dangerouslyAllowAll && decision.action !== 'allow') {
-    return {
-      output: permissionDeniedOutput(TOOL_NAME, decision),
-      permissionDenials: [{ tool: TOOL_NAME, action: decision.action, reason: 'permission' }],
-    };
-  }
-  const output = `Oracle: ${fixtureAgentResponse(request.flags.prompt, '')}`;
-  const resultDecision = await runPluginEventHandlers(
-    plugins.handlers['tool.result'],
-    pluginToolResultEvent(TOOL_NAME, request.flags, 'done', output, threadId, toolUseID),
-  );
-  return {
-    ...pluginTextToolRunResult(resultDecision, output),
-    toolUse: pluginToolUseBlock(TOOL_NAME, request.flags, toolUseID),
-  };
-}
-
-function normalizeOracleInput(input = {}) {
-  const prompt = input.prompt ?? input.question ?? input.query ?? input.message;
-  return {
-    ...input,
-    prompt: prompt ? String(prompt) : '',
-  };
-}

package/src/tools/builtin/painter.mjs

@@ -1,81 +0,0 @@
-import { mkdirSync, writeFileSync } from 'node:fs';
-import path from 'node:path';
-import { resolvePermissionDecision } from '../../commands/permissions.mjs';
-import { runPluginEventHandlers } from '../../plugins/discover.mjs';
-import { isToolDisabled } from '../toolbox.mjs';
-import {
-  applyToolCallDecision,
-  createToolUseID,
-  permissionDeniedOutput,
-  pluginTextToolRunResult,
-  pluginToolCallEvent,
-  pluginToolResultEvent,
-  pluginToolUseBlock,
-  toolCallDecisionToolRun,
-  validateToolCallDecision,
-} from './runtime.mjs';
-
-export const TOOL_NAME = 'painter';
-
-const PAINTER_PLACEHOLDER_PNG = Buffer.from(
-  'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M/wHwAFeAKU5XgS2wAAAABJRU5ErkJggg==',
-  'base64',
-);
-
-export async function executePromptPainterToolRequest(request, parsed = {}, plugins = { handlers: {} }, threadId = '') {
-  if (isToolDisabled(TOOL_NAME, 'built-in', parsed)) return { output: `Tool disabled: ${TOOL_NAME}` };
-  request = { ...request, flags: normalizePainterInput(request.flags) };
-  if (!request.flags.prompt) return { output: 'painter requires --prompt' };
-  const toolUseID = createToolUseID();
-  const callDecision = await runPluginEventHandlers(
-    plugins.handlers['tool.call'],
-    pluginToolCallEvent(TOOL_NAME, request.flags, threadId, toolUseID),
-    validateToolCallDecision,
-  );
-  const callResult = applyToolCallDecision(TOOL_NAME, request, callDecision);
-  if (callResult.output) return toolCallDecisionToolRun(TOOL_NAME, request.flags, toolUseID, callResult);
-  request = { ...callResult.request, flags: normalizePainterInput(callResult.request.flags) };
-  const decision = resolvePermissionDecision(TOOL_NAME, request.flags, parsed, { threadId });
-  if (!parsed.dangerouslyAllowAll && decision.action !== 'allow') {
-    return {
-      output: permissionDeniedOutput(TOOL_NAME, decision),
-      permissionDenials: [{ tool: TOOL_NAME, action: decision.action, reason: 'permission' }],
-    };
-  }
-  const output = writePainterArtifact(request.flags);
-  const resultDecision = await runPluginEventHandlers(
-    plugins.handlers['tool.result'],
-    pluginToolResultEvent(TOOL_NAME, request.flags, 'done', output, threadId, toolUseID),
-  );
-  return {
-    ...pluginTextToolRunResult(resultDecision, output),
-    toolUse: pluginToolUseBlock(TOOL_NAME, request.flags, toolUseID),
-  };
-}
-
-function normalizePainterInput(input = {}) {
-  const prompt = input.prompt ?? input.description ?? input.text ?? '';
-  const output = input.output ?? input.path ?? input.file ?? 'coven-code-painter-output.png';
-  const references = [input.reference, input.references, input.image, input.images]
-    .flat()
-    .filter(Boolean)
-    .map(String);
-  return {
-    ...input,
-    prompt: String(prompt),
-    output: String(output),
-    references,
-  };
-}
-
-function writePainterArtifact(input) {
-  const outputPath = path.resolve(process.cwd(), input.output);
-  mkdirSync(path.dirname(outputPath), { recursive: true });
-  writeFileSync(outputPath, PAINTER_PLACEHOLDER_PNG);
-  return [
-    `Generated image: ${input.output}`,
-    'media_type: image/png',
-    `prompt: ${input.prompt}`,
-    ...(input.references.length ? [`references: ${input.references.join(', ')}`] : []),
-  ].join('\n');
-}

package/src/tools/builtin/plugin-tool.mjs

@@ -1,53 +0,0 @@
-import { resolvePermissionDecision } from '../../commands/permissions.mjs';
-import { createPluginToolContext, runPluginEventHandlers } from '../../plugins/discover.mjs';
-import { isToolDisabled } from '../toolbox.mjs';
-import {
-  applyToolCallDecision,
-  createToolUseID,
-  normalizePluginToolExecuteOutput,
-  normalizePluginToolOutput,
-  permissionDeniedOutput,
-  pluginToolCallEvent,
-  pluginToolResultDecisionExitCode,
-  pluginToolResultDecisionOutput,
-  pluginToolResultEvent,
-  pluginToolUseBlock,
-  toolCallDecisionToolRun,
-  validateToolCallDecision,
-} from './runtime.mjs';
-
-export async function executePromptPluginToolRequest(tool, request, parsed = {}, plugins = { handlers: {} }, threadId = '') {
-  if (isToolDisabled(tool.name, 'plugin', parsed)) return { output: `Tool disabled: ${tool.name}` };
-  const toolUseID = createToolUseID();
-  const callDecision = await runPluginEventHandlers(
-    plugins.handlers['tool.call'],
-    pluginToolCallEvent(tool.name, request.flags, threadId, toolUseID),
-    validateToolCallDecision,
-  );
-  const callResult = applyToolCallDecision(tool.name, request, callDecision);
-  if (callResult.output) return toolCallDecisionToolRun(tool.name, request.flags, toolUseID, callResult);
-  request = callResult.request;
-  const decision = resolvePermissionDecision(tool.name, request.flags, parsed, { threadId });
-  if (!parsed.dangerouslyAllowAll && decision.action !== 'allow') {
-    return {
-      output: permissionDeniedOutput(tool.name, decision),
-      permissionDenials: [{ tool: tool.name, action: decision.action, reason: 'permission' }],
-    };
-  }
-  const output = typeof tool.execute === 'function' ? await tool.execute(request.flags, createPluginToolContext()) : undefined;
-  const normalizedOutput = normalizePluginToolExecuteOutput(output);
-  const resultDecision = await runPluginEventHandlers(
-    plugins.handlers['tool.result'],
-    pluginToolResultEvent(tool.name, request.flags, 'done', normalizedOutput.raw, threadId, toolUseID),
-  );
-  const finalOutput = normalizePluginToolOutput(
-    pluginToolResultDecisionOutput(resultDecision, normalizedOutput.raw),
-  );
-  const exitCode = pluginToolResultDecisionExitCode(resultDecision);
-  return {
-    output: finalOutput.text,
-    toolResultOutput: finalOutput.raw,
-    exitCode,
-    toolUse: pluginToolUseBlock(tool.name, request.flags, toolUseID),
-  };
-}