wormclaude 1.0.0

package/dist/tools.js

@@ -0,0 +1,1136 @@
+// Araçlar — WormClaude araç setinin birebir uyarlaması (WormClaude'a göre).
+// OpenAI function şemaları + Node executor'ları. Açıklamalar ve davranışlar
+// WormClaude'un gerçek prompt.ts/şemalarından alınmıştır; sadece marka adı ve
+// WormClaude'da bulunmayan araç referansları (Agent tool, sandbox) uyarlandı.
+import { execSync, spawn } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { loadConfig } from './api.js';
+import { runAgentLoop } from './agent.js';
+import { tasks } from './tasks.js';
+import { getMcpToolSchemas, callMcpTool } from './mcp.js';
+import { getAutoSkills, getSkill, buildSkillPrompt } from './skills.js';
+// Agent/alt-agent araçlarının backend'e ulaşması için config. cli.tsx başlangıçta
+// setToolConfig ile aynı (mutable) config nesnesini verir → /config değişiklikleri görülür.
+let toolConfig = null;
+export function setToolConfig(c) { toolConfig = c; }
+function cfg() { return toolConfig ?? loadConfig(); }
+let todosStore = []; // TodoWrite durumu
+export function getTodos() { return todosStore; }
+const MAX_LINES_TO_READ = 2000;
+const DEFAULT_BASH_TIMEOUT_MS = 120000;
+const MAX_BASH_TIMEOUT_MS = 600000;
+// WormClaude davranışı: bir dosyayı düzenlemeden/üzerine yazmadan önce
+// en az bir kez okumuş olman gerekir. Okunan dosyaları burada izliyoruz.
+const readFiles = new Set();
+function norm(p) {
+    try {
+        return path.resolve(p).toLowerCase();
+    }
+    catch {
+        return p;
+    }
+}
+// ── Araç açıklamaları (WormClaude prompt.ts'lerinden birebir) ────────────────
+const BASH_DESCRIPTION = `Executes a given bash command and returns its output.
+
+The working directory persists between commands, but shell state does not. The shell environment is initialized from the user's profile (bash or zsh).
+
+IMPORTANT: Avoid using this tool to run \`find\`, \`grep\`, \`cat\`, \`head\`, \`tail\`, \`sed\`, \`awk\`, or \`echo\` commands, unless explicitly instructed or after you have verified that a dedicated tool cannot accomplish your task. Instead, use the appropriate dedicated tool as this will provide a much better experience for the user:
+
+- File search: Use Glob (NOT find or ls)
+- Content search: Use Grep (NOT grep or rg)
+- Read files: Use Read (NOT cat/head/tail)
+- Edit files: Use Edit (NOT sed/awk)
+- Write files: Use Write (NOT echo >/cat <<EOF)
+- Communication: Output text directly (NOT echo/printf)
+
+While the Bash tool can do similar things, it's better to use the built-in tools as they provide a better user experience and make it easier to review tool calls and give permission.
+
+# Instructions
+- If your command will create new directories or files, first use this tool to run \`ls\` to verify the parent directory exists and is the correct location.
+- Always quote file paths that contain spaces with double quotes in your command (e.g., cd "path with spaces/file.txt")
+- Try to maintain your current working directory throughout the session by using absolute paths and avoiding usage of \`cd\`. You may use \`cd\` if the User explicitly requests it.
+- You may specify an optional timeout in milliseconds (up to ${MAX_BASH_TIMEOUT_MS}ms / ${MAX_BASH_TIMEOUT_MS / 60000} minutes). By default, your command will timeout after ${DEFAULT_BASH_TIMEOUT_MS}ms (${DEFAULT_BASH_TIMEOUT_MS / 60000} minutes).
+- When issuing multiple commands:
+  - If the commands depend on each other and must run sequentially, use a single Bash call with '&&' to chain them together.
+  - Use ';' only when you need to run commands sequentially but don't care if earlier commands fail.
+  - DO NOT use newlines to separate commands (newlines are ok in quoted strings).
+- For git commands:
+  - Prefer to create a new commit rather than amending an existing commit.
+  - Before running destructive operations (e.g., git reset --hard, git push --force, git checkout --), consider whether there is a safer alternative that achieves the same goal. Only use destructive operations when they are truly the best approach.
+  - Never skip hooks (--no-verify) or bypass signing unless the user has explicitly asked for it. If a hook fails, investigate and fix the underlying issue.
+- Avoid unnecessary \`sleep\` commands: do not sleep between commands that can run immediately — just run them.`;
+const READ_DESCRIPTION = `Reads a file from the local filesystem. You can access any file directly by using this tool.
+Assume this tool is able to read all files on the machine. If the User provides a path to a file assume that path is valid. It is okay to read a file that does not exist; an error will be returned.
+
+Usage:
+- The file_path parameter must be an absolute path, not a relative path
+- By default, it reads up to ${MAX_LINES_TO_READ} lines starting from the beginning of the file
+- You can optionally specify a line offset and limit (especially handy for long files), but it's recommended to read the whole file by not providing these parameters
+- Results are returned using cat -n format, with line numbers starting at 1
+- This tool can only read files, not directories. To read a directory, use an ls command via the Bash tool.
+- If you read a file that exists but has empty contents you will receive a system reminder warning in place of file contents.`;
+const WRITE_DESCRIPTION = `Writes a file to the local filesystem.
+
+Usage:
+- This tool will overwrite the existing file if there is one at the provided path.
+- If this is an existing file, you MUST use the Read tool first to read the file's contents. This tool will fail if you did not read the file first.
+- Prefer the Edit tool for modifying existing files — it only sends the diff. Only use this tool to create new files or for complete rewrites.
+- NEVER create documentation files (*.md) or README files unless explicitly requested by the User.
+- Only use emojis if the user explicitly requests it. Avoid writing emojis to files unless asked.`;
+const EDIT_DESCRIPTION = `Performs exact string replacements in files.
+
+Usage:
+- You must use your \`Read\` tool at least once in the conversation before editing. This tool will error if you attempt an edit without reading the file.
+- When editing text from Read tool output, ensure you preserve the exact indentation (tabs/spaces) as it appears AFTER the line number prefix. The line number prefix format is: spaces + line number + tab. Everything after that is the actual file content to match. Never include any part of the line number prefix in the old_string or new_string.
+- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.
+- Only use emojis if the user explicitly requests it. Avoid adding emojis to files unless asked.
+- The edit will FAIL if \`old_string\` is not unique in the file. Either provide a larger string with more surrounding context to make it unique or use \`replace_all\` to change every instance of \`old_string\`.
+- Use \`replace_all\` for replacing and renaming strings across the file. This parameter is useful if you want to rename a variable for instance.`;
+const GLOB_DESCRIPTION = `- Fast file pattern matching tool that works with any codebase size
+- Supports glob patterns like "**/*.js" or "src/**/*.ts"
+- Returns matching file paths sorted by modification time
+- Use this tool when you need to find files by name patterns`;
+const GREP_DESCRIPTION = `A powerful search tool built on ripgrep
+
+Usage:
+- ALWAYS use Grep for search tasks. NEVER invoke \`grep\` or \`rg\` as a Bash command. The Grep tool has been optimized for correct permissions and access.
+- Supports full regex syntax (e.g., "log.*Error", "function\\s+\\w+")
+- Filter files with glob parameter (e.g., "*.js", "**/*.tsx") or type parameter (e.g., "js", "py", "rust")
+- Output modes: "content" shows matching lines, "files_with_matches" shows only file paths (default), "count" shows match counts
+- Pattern syntax: literal braces need escaping (use \`interface\\{\\}\` to find \`interface{}\` in Go code)
+- Multiline matching: By default patterns match within single lines only. For cross-line patterns like \`struct \\{[\\s\\S]*?field\`, use \`multiline: true\``;
+const AGENT_DESCRIPTION = `Launch a new sub-agent to handle a complex, multi-step task autonomously.
+
+The sub-agent runs its own tool-calling loop (Bash, Read, Write, Edit, Glob, Grep, WebFetch) against the same model, then returns a final summary. Use this to:
+- Delegate a self-contained subtask (e.g. "find and fix all usages of X", "investigate why Y fails")
+- Parallelize independent work by launching several background agents at once (coordinator pattern)
+
+Usage:
+- description: a short (3-5 word) description of the task
+- prompt: the detailed, self-contained instruction for the sub-agent (it has no memory of this conversation — include all needed context, file paths, and exactly what to return)
+- run_in_background: if true, returns a task id immediately and the agent works in the background; read its result later with TaskOutput. If false (default), blocks until the sub-agent finishes and returns its result directly.
+- The sub-agent CANNOT launch further sub-agents (no nesting).`;
+const TASKOUTPUT_DESCRIPTION = `Read the current output and status of a background task (shell command or sub-agent) previously started with run_in_background. Returns the task status and its accumulated output.`;
+const WEBFETCH_DESCRIPTION = `- Fetches content from a specified URL
+- Takes a URL and a prompt as input
+- Fetches the URL content, converts HTML to text
+- Returns the page content for analysis against the prompt
+- Use this tool when you need to retrieve and analyze web content
+
+Usage notes:
+  - The URL must be a fully-formed valid URL
+  - HTTP URLs will be automatically upgraded to HTTPS
+  - The prompt should describe what information you want to extract from the page
+  - This tool is read-only and does not modify any files
+  - For GitHub URLs, prefer using the gh CLI via Bash instead (e.g., gh pr view, gh issue view, gh api).`;
+// ── Şemalar (OpenAI function-calling formatı) ─────────────────────────────────
+export const toolSchemas = [
+    {
+        type: 'function',
+        function: {
+            name: 'Bash',
+            description: BASH_DESCRIPTION,
+            parameters: {
+                type: 'object',
+                properties: {
+                    command: { type: 'string', description: 'The command to execute' },
+                    timeout: { type: 'number', description: `Optional timeout in milliseconds (max ${MAX_BASH_TIMEOUT_MS})` },
+                    description: {
+                        type: 'string',
+                        description: 'Clear, concise description of what this command does in active voice. Never use words like "complex" or "risk" in the description - just describe what it does.',
+                    },
+                    run_in_background: {
+                        type: 'boolean',
+                        description: "Set to true to run this command in the background. Returns a task id immediately; read output later with TaskOutput. You don't need '&' at the end.",
+                    },
+                },
+                required: ['command'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'Read',
+            description: READ_DESCRIPTION,
+            parameters: {
+                type: 'object',
+                properties: {
+                    file_path: { type: 'string', description: 'The absolute path to the file to read' },
+                    offset: {
+                        type: 'number',
+                        description: 'The line number to start reading from. Only provide if the file is too large to read at once',
+                    },
+                    limit: {
+                        type: 'number',
+                        description: 'The number of lines to read. Only provide if the file is too large to read at once.',
+                    },
+                },
+                required: ['file_path'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'Write',
+            description: WRITE_DESCRIPTION,
+            parameters: {
+                type: 'object',
+                properties: {
+                    file_path: {
+                        type: 'string',
+                        description: 'The absolute path to the file to write (must be absolute, not relative)',
+                    },
+                    content: { type: 'string', description: 'The content to write to the file' },
+                },
+                required: ['file_path', 'content'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'Edit',
+            description: EDIT_DESCRIPTION,
+            parameters: {
+                type: 'object',
+                properties: {
+                    file_path: { type: 'string', description: 'The absolute path to the file to modify' },
+                    old_string: { type: 'string', description: 'The text to replace' },
+                    new_string: {
+                        type: 'string',
+                        description: 'The text to replace it with (must be different from old_string)',
+                    },
+                    replace_all: {
+                        type: 'boolean',
+                        description: 'Replace all occurrences of old_string (default false)',
+                    },
+                },
+                required: ['file_path', 'old_string', 'new_string'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'Glob',
+            description: GLOB_DESCRIPTION,
+            parameters: {
+                type: 'object',
+                properties: {
+                    pattern: { type: 'string', description: 'The glob pattern to match files against' },
+                    path: {
+                        type: 'string',
+                        description: 'The directory to search in. If not specified, the current working directory will be used. IMPORTANT: Omit this field to use the default directory. DO NOT enter "undefined" or "null" - simply omit it for the default behavior. Must be a valid directory path if provided.',
+                    },
+                },
+                required: ['pattern'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'Grep',
+            description: GREP_DESCRIPTION,
+            parameters: {
+                type: 'object',
+                properties: {
+                    pattern: { type: 'string', description: 'The regular expression pattern to search for in file contents' },
+                    path: {
+                        type: 'string',
+                        description: 'File or directory to search in. Defaults to current working directory.',
+                    },
+                    glob: {
+                        type: 'string',
+                        description: 'Glob pattern to filter files (e.g. "*.js", "*.{ts,tsx}")',
+                    },
+                    output_mode: {
+                        type: 'string',
+                        enum: ['content', 'files_with_matches', 'count'],
+                        description: 'Output mode: "content" shows matching lines (supports -A/-B/-C context, -n line numbers, head_limit), "files_with_matches" shows file paths (supports head_limit), "count" shows match counts. Defaults to "files_with_matches".',
+                    },
+                    '-B': { type: 'number', description: 'Number of lines to show before each match. Requires output_mode: "content".' },
+                    '-A': { type: 'number', description: 'Number of lines to show after each match. Requires output_mode: "content".' },
+                    '-C': { type: 'number', description: 'Alias for context.' },
+                    context: { type: 'number', description: 'Number of lines to show before and after each match. Requires output_mode: "content".' },
+                    '-n': { type: 'boolean', description: 'Show line numbers in output. Requires output_mode: "content". Defaults to true.' },
+                    '-i': { type: 'boolean', description: 'Case insensitive search' },
+                    type: {
+                        type: 'string',
+                        description: 'File type to search. Common types: js, ts, py, rust, go, java, etc.',
+                    },
+                    head_limit: {
+                        type: 'number',
+                        description: 'Limit output to first N lines/entries. Works across all output modes. Defaults to 250 when unspecified.',
+                    },
+                    offset: { type: 'number', description: 'Skip first N lines/entries before applying head_limit. Defaults to 0.' },
+                    multiline: {
+                        type: 'boolean',
+                        description: 'Enable multiline mode where . matches newlines and patterns can span lines. Default: false.',
+                    },
+                },
+                required: ['pattern'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'WebFetch',
+            description: WEBFETCH_DESCRIPTION,
+            parameters: {
+                type: 'object',
+                properties: {
+                    url: { type: 'string', description: 'The URL to fetch content from' },
+                    prompt: { type: 'string', description: 'The prompt to run on the fetched content' },
+                },
+                required: ['url', 'prompt'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'Agent',
+            description: AGENT_DESCRIPTION,
+            parameters: {
+                type: 'object',
+                properties: {
+                    description: { type: 'string', description: 'A short (3-5 word) description of the task' },
+                    prompt: { type: 'string', description: 'The detailed, self-contained task for the sub-agent to perform' },
+                    run_in_background: { type: 'boolean', description: 'Run the sub-agent in the background and return a task id (default false)' },
+                },
+                required: ['description', 'prompt'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'TaskOutput',
+            description: TASKOUTPUT_DESCRIPTION,
+            parameters: {
+                type: 'object',
+                properties: {
+                    task_id: { type: 'string', description: 'The id of the background task to read (e.g. shell_1, agent_2)' },
+                },
+                required: ['task_id'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'WebSearch',
+            description: 'Search the web and return top results (title, url, snippet). Use for current info, docs, or finding pages to WebFetch.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    query: { type: 'string', description: 'The search query' },
+                    max_results: { type: 'number', description: 'Max results to return (default 5)' },
+                },
+                required: ['query'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'TodoWrite',
+            description: 'Create/update a structured task list for the current work. Use for multi-step tasks to track progress. Pass the FULL list each time.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    todos: {
+                        type: 'array',
+                        description: 'The full todo list',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                content: { type: 'string', description: 'Task description' },
+                                status: { type: 'string', enum: ['pending', 'in_progress', 'completed'], description: 'Task status' },
+                            },
+                            required: ['content', 'status'],
+                        },
+                    },
+                },
+                required: ['todos'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'PowerShell',
+            description: 'Execute a Windows PowerShell command and return its output. Use for Windows-specific tasks; otherwise prefer Bash.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    command: { type: 'string', description: 'The PowerShell command to execute' },
+                    timeout: { type: 'number', description: `Optional timeout in ms (max ${MAX_BASH_TIMEOUT_MS})` },
+                },
+                required: ['command'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'NotebookEdit',
+            description: 'Edit a Jupyter notebook (.ipynb) cell. edit_mode: replace (default), insert, or delete.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    notebook_path: { type: 'string', description: 'Absolute path to the .ipynb file' },
+                    cell_index: { type: 'number', description: 'Zero-based index of the cell to edit/insert at' },
+                    new_source: { type: 'string', description: 'New cell source (for replace/insert)' },
+                    cell_type: { type: 'string', enum: ['code', 'markdown'], description: 'Cell type for insert' },
+                    edit_mode: { type: 'string', enum: ['replace', 'insert', 'delete'], description: 'Edit mode (default replace)' },
+                },
+                required: ['notebook_path', 'cell_index'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'REPL',
+            description: 'Run a code snippet in node or python and return stdout/stderr. One-shot (no persisted state).',
+            parameters: {
+                type: 'object',
+                properties: {
+                    language: { type: 'string', enum: ['node', 'python'], description: 'Runtime' },
+                    code: { type: 'string', description: 'Code to execute' },
+                },
+                required: ['language', 'code'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'LSP',
+            description: 'Find a symbol definition or references in the codebase (heuristic, ripgrep-based — not a full language server).',
+            parameters: {
+                type: 'object',
+                properties: {
+                    action: { type: 'string', enum: ['definition', 'references'], description: 'What to find' },
+                    symbol: { type: 'string', description: 'The symbol name (function/class/variable)' },
+                    path: { type: 'string', description: 'Base directory (default cwd)' },
+                },
+                required: ['action', 'symbol'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'Sleep',
+            description: 'Pause for N seconds (max 60). Use sparingly, e.g. waiting for a process to settle.',
+            parameters: {
+                type: 'object',
+                properties: { seconds: { type: 'number', description: 'Seconds to wait (max 60)' } },
+                required: ['seconds'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'AskUserQuestion',
+            description: 'Ask the user a multiple-choice question and get their answer. Use when you need a decision only the user can make.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    question: { type: 'string', description: 'The question to ask' },
+                    options: {
+                        type: 'array',
+                        description: '2-4 options',
+                        items: { type: 'object', properties: { label: { type: 'string' }, description: { type: 'string' } }, required: ['label'] },
+                    },
+                },
+                required: ['question', 'options'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'EnterPlanMode',
+            description: 'Enter read-only planning mode: investigate and write a plan; file edits and commands are blocked until ExitPlanMode is approved.',
+            parameters: { type: 'object', properties: {}, required: [] },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'ExitPlanMode',
+            description: 'Present your plan to the user for approval and exit plan mode. On approval you may proceed with edits/commands.',
+            parameters: {
+                type: 'object',
+                properties: { plan: { type: 'string', description: 'The plan to present (markdown)' } },
+                required: ['plan'],
+            },
+        },
+    },
+];
+// autoInvoke skill'leri model'e tek bir 'Skill' aracı olarak sunar.
+function skillToolSchema() {
+    const auto = getAutoSkills();
+    if (!auto.length)
+        return null;
+    const list = auto.map((s) => `- ${s.name}: ${s.description}${s.whenToUse ? ` (${s.whenToUse})` : ''}`).join('\n');
+    return {
+        type: 'function',
+        function: {
+            name: 'Skill',
+            description: 'Invoke a specialized skill (an expert prompt pack) when the task matches one. ' +
+                'The skill runs as a focused sub-agent and returns its result. Available skills:\n' + list,
+            parameters: {
+                type: 'object',
+                properties: {
+                    name: { type: 'string', enum: auto.map((s) => s.name), description: 'The skill to invoke' },
+                    args: { type: 'string', description: 'Optional context/arguments for the skill' },
+                },
+                required: ['name'],
+            },
+        },
+    };
+}
+// Yerleşik + MCP + autoInvoke-skill araçlarının tümü. Ana döngü ve alt-agent'lar kullanır.
+export function allToolSchemas() {
+    const sk = skillToolSchema();
+    return [...toolSchemas, ...getMcpToolSchemas(), ...(sk ? [sk] : [])];
+}
+const TOOL_META = {
+    Read: { readOnly: true, concurrencySafe: true },
+    Glob: { readOnly: true, concurrencySafe: true },
+    Grep: { readOnly: true, concurrencySafe: true },
+    WebFetch: { readOnly: true, needsPermission: true, validate: (a) => (a && a.url ? null : 'url gerekli') },
+    TaskOutput: { readOnly: true, concurrencySafe: true },
+    Bash: { needsPermission: true, validate: (a) => (a && a.command ? null : 'command gerekli') },
+    Write: { needsPermission: true, validate: (a) => (a && a.file_path ? null : 'file_path gerekli') },
+    Edit: { needsPermission: true, validate: (a) => (a && a.file_path && a.old_string != null ? null : 'file_path ve old_string gerekli') },
+    Agent: { validate: (a) => (a && a.prompt ? null : 'prompt gerekli') },
+    WebSearch: { readOnly: true, needsPermission: true, validate: (a) => (a && a.query ? null : 'query gerekli') },
+    TodoWrite: { readOnly: true, validate: (a) => (a && Array.isArray(a.todos) ? null : 'todos dizisi gerekli') },
+    PowerShell: { needsPermission: true, validate: (a) => (a && a.command ? null : 'command gerekli') },
+    NotebookEdit: { needsPermission: true, validate: (a) => (a && a.notebook_path ? null : 'notebook_path gerekli') },
+    REPL: { needsPermission: true, validate: (a) => (a && a.language && a.code ? null : 'language ve code gerekli') },
+    LSP: { readOnly: true, concurrencySafe: true, validate: (a) => (a && a.symbol ? null : 'symbol gerekli') },
+    Sleep: { readOnly: true, concurrencySafe: true },
+    AskUserQuestion: { readOnly: true, validate: (a) => (a && a.question && Array.isArray(a.options) ? null : 'question ve options gerekli') },
+    EnterPlanMode: { readOnly: true },
+    ExitPlanMode: { readOnly: true, validate: (a) => (a && a.plan ? null : 'plan gerekli') },
+};
+// Plan modu: açıkken yazma/komut araçları engellenir (ExitPlanMode onayına kadar).
+let planMode = false;
+export function isPlanMode() { return planMode; }
+const MAX_TOOL_CONCURRENCY = Number(process.env.WORMCLAUDE_MAX_TOOL_CONCURRENCY) || 10;
+export function isConcurrencySafe(name) {
+    return TOOL_META[name]?.concurrencySafe ?? false; // bilinmeyen/MCP → sıralı (güvenli taraf)
+}
+export function isReadOnly(name) {
+    return TOOL_META[name]?.readOnly ?? false;
+}
+export function needsPermission(name) {
+    return TOOL_META[name]?.needsPermission ?? false; // MCP/diğer → varsayılan izin gerekmez
+}
+export function validateToolInput(name, args) {
+    return TOOL_META[name]?.validate?.(args) ?? null;
+}
+async function execOne(call, hooks) {
+    let args = {};
+    try {
+        args = JSON.parse(call.args || '{}');
+    }
+    catch { }
+    // 1) Girdi doğrulama
+    const verr = validateToolInput(call.name, args);
+    if (verr)
+        return { ok: false, output: `Geçersiz girdi: ${verr}`, args };
+    // 2) İnteraktif/plan araçları
+    if (call.name === 'AskUserQuestion') {
+        const opts = Array.isArray(args.options) ? args.options : [];
+        if (hooks?.ask) {
+            const ch = await hooks.ask({ question: String(args.question), options: opts });
+            return { ok: true, output: ch, args };
+        }
+        return { ok: true, output: opts[0]?.label || '(no UI)', args };
+    }
+    if (call.name === 'EnterPlanMode') {
+        planMode = true;
+        return { ok: true, output: 'Plan modu açık. Araştır ve planı yaz; yazma/komut engelli. ExitPlanMode(plan) ile onay iste.', args };
+    }
+    if (call.name === 'ExitPlanMode') {
+        let approved = true;
+        if (hooks?.ask) {
+            const ch = await hooks.ask({ question: String(args.plan || ''), options: [{ label: 'Onayla / Approve' }, { label: 'Reddet / Reject' }] });
+            approved = /onayla|approve/i.test(ch);
+        }
+        if (approved) {
+            planMode = false;
+            return { ok: true, output: 'Plan onaylandı — uygulamaya geçebilirsin.', args };
+        }
+        return { ok: true, output: 'Plan reddedildi — plan modunda kal ve düzelt.', args };
+    }
+    // 3) Plan modu zorlaması: yazma/komut araçları engelli
+    if (planMode && !isReadOnly(call.name)) {
+        return { ok: false, output: 'Plan modunda — yazma/komut engellendi. Önce ExitPlanMode ile planı onaylat.', args };
+    }
+    // 4) İzin (gerekiyorsa)
+    if (needsPermission(call.name) && hooks?.confirm) {
+        const decision = await hooks.confirm(call, args);
+        if (decision !== 'allow') {
+            const fb = typeof decision === 'object' && decision.deny ? decision.deny : '';
+            return { ok: false, output: fb ? `Kullanıcı bu aracı reddetti. Bunun yerine şunu yap: ${fb}` : 'Kullanıcı bu aracı reddetti.', args };
+        }
+    }
+    // 5) Çalıştır
+    const res = await executeTool(call.name, args);
+    return { ...res, args };
+}
+// Araç çağrılarını ardışık güvenlik durumuna göre batch'ler; güvenli batch'leri
+// paralel (limit MAX), diğerlerini sıralı çalıştırır. Sonuçları ORİJİNAL sırada döndürür.
+export async function executeToolCalls(calls, hooks) {
+    const results = new Array(calls.length);
+    const batches = [];
+    calls.forEach((c, i) => {
+        const safe = isConcurrencySafe(c.name);
+        const last = batches[batches.length - 1];
+        if (last && last.safe === safe)
+            last.items.push({ c, i });
+        else
+            batches.push({ safe, items: [{ c, i }] });
+    });
+    for (const b of batches) {
+        if (b.safe && b.items.length > 1) {
+            let p = 0;
+            const worker = async () => {
+                while (p < b.items.length) {
+                    const { c, i } = b.items[p++];
+                    hooks?.onStart?.(c, i);
+                    results[i] = await execOne(c, hooks);
+                    hooks?.onResult?.(c, i, results[i]);
+                }
+            };
+            await Promise.all(Array.from({ length: Math.min(MAX_TOOL_CONCURRENCY, b.items.length) }, worker));
+        }
+        else {
+            for (const { c, i } of b.items) {
+                hooks?.onStart?.(c, i);
+                results[i] = await execOne(c, hooks);
+                hooks?.onResult?.(c, i, results[i]);
+            }
+        }
+    }
+    return results;
+}
+// Alt-agent'a verilecek araç seti (özyineleme/iç içe agent engellenir).
+function subAgentTools() {
+    return allToolSchemas().filter((t) => t.function.name !== 'Agent' && t.function.name !== 'Skill');
+}
+const SUBAGENT_SYSTEM = 'You are a WormClaude sub-agent: an autonomous worker spawned to complete one specific task. ' +
+    'Use your tools (Bash, Read, Write, Edit, Glob, Grep, WebFetch, TaskOutput) to do the work, ' +
+    'then return a concise final report of what you did and any results requested. ' +
+    'You have no memory beyond this task. Be thorough and finish the task end-to-end.';
+export function toolLabel(name, args) {
+    try {
+        if (name === 'Bash')
+            return `Bash(${String(args.command).slice(0, 80)})`;
+        if (name === 'Read')
+            return `Read(${args.file_path})`;
+        if (name === 'Write')
+            return `Write(${args.file_path})`;
+        if (name === 'Edit')
+            return `Edit(${args.file_path})`;
+        if (name === 'Glob')
+            return `Glob(${args.pattern})`;
+        if (name === 'Grep')
+            return `Grep(${args.pattern})`;
+        if (name === 'WebFetch')
+            return `WebFetch(${args.url})`;
+        if (name === 'Agent')
+            return `Agent(${args.description || ''}${args.run_in_background ? ', bg' : ''})`;
+        if (name === 'TaskOutput')
+            return `TaskOutput(${args.task_id})`;
+        if (name === 'Skill')
+            return `Skill(${args.name})`;
+        if (name === 'WebSearch')
+            return `WebSearch(${args.query})`;
+        if (name === 'TodoWrite')
+            return `TodoWrite(${(args.todos || []).length} öğe)`;
+        if (name === 'PowerShell')
+            return `PowerShell(${String(args.command).slice(0, 60)})`;
+        if (name === 'NotebookEdit')
+            return `NotebookEdit(${args.notebook_path}, ${args.edit_mode || 'replace'})`;
+        if (name === 'REPL')
+            return `REPL(${args.language})`;
+        if (name === 'LSP')
+            return `LSP(${args.action}: ${args.symbol})`;
+        if (name === 'Sleep')
+            return `Sleep(${args.seconds}s)`;
+        if (name === 'AskUserQuestion')
+            return `AskUserQuestion(${String(args.question).slice(0, 50)})`;
+        if (name === 'EnterPlanMode')
+            return 'EnterPlanMode()';
+        if (name === 'ExitPlanMode')
+            return 'ExitPlanMode()';
+        if (name.startsWith('mcp__')) {
+            const parts = name.split('__');
+            return `MCP·${parts[1]}(${parts.slice(2).join('__')})`;
+        }
+    }
+    catch { }
+    return `${name}(...)`;
+}
+// ── Yardımcılar ───────────────────────────────────────────────────────────────
+function walk(dir, out, depth = 0) {
+    if (depth > 12 || out.length > 20000)
+        return;
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const e of entries) {
+        if (e.name === 'node_modules' || e.name === '.git')
+            continue;
+        const full = path.join(dir, e.name);
+        if (e.isDirectory())
+            walk(full, out, depth + 1);
+        else
+            out.push(full);
+    }
+}
+function globToRegex(pattern) {
+    let re = pattern
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*\*/g, '')
+        .replace(/\*/g, '[^/\\\\]*')
+        .replace(//g, '.*')
+        .replace(/\?/g, '.');
+    return new RegExp(re + '$', 'i');
+}
+const TYPE_EXT = {
+    js: ['js', 'jsx', 'mjs', 'cjs'],
+    ts: ['ts', 'tsx', 'mts', 'cts'],
+    py: ['py', 'pyi'],
+    rust: ['rs'],
+    go: ['go'],
+    java: ['java'],
+    c: ['c', 'h'],
+    cpp: ['cpp', 'cc', 'cxx', 'hpp', 'hh'],
+    json: ['json'],
+    md: ['md', 'markdown'],
+    html: ['html', 'htm'],
+    css: ['css', 'scss', 'sass'],
+    sh: ['sh', 'bash', 'zsh'],
+};
+// ── Executor ──────────────────────────────────────────────────────────────────
+export async function executeTool(name, args) {
+    try {
+        if (name === 'Bash') {
+            if (args.run_in_background) {
+                const task = tasks.create('shell', String(args.command).slice(0, 60));
+                const child = spawn(String(args.command), { shell: true, windowsHide: true });
+                task.child = child;
+                child.stdout?.on('data', (d) => tasks.append(task.id, d.toString()));
+                child.stderr?.on('data', (d) => tasks.append(task.id, d.toString()));
+                child.on('close', (code) => {
+                    tasks.append(task.id, `\n[exit ${code}]`);
+                    tasks.finish(task.id, code === 0 ? 'done' : 'error');
+                });
+                child.on('error', (e) => { tasks.append(task.id, `\n[spawn error: ${e.message}]`); tasks.finish(task.id, 'error'); });
+                return { ok: true, output: `Background task started: ${task.id}. Read output later with TaskOutput("${task.id}").` };
+            }
+            let timeout = Number(args.timeout) || DEFAULT_BASH_TIMEOUT_MS;
+            if (timeout > MAX_BASH_TIMEOUT_MS)
+                timeout = MAX_BASH_TIMEOUT_MS;
+            const out = execSync(String(args.command), {
+                encoding: 'utf8', timeout, maxBuffer: 10 * 1024 * 1024, windowsHide: true,
+            });
+            return { ok: true, output: (out || '(no output)').slice(0, 20000) };
+        }
+        if (name === 'Agent') {
+            const subMessages = [
+                { role: 'system', content: SUBAGENT_SYSTEM },
+                { role: 'user', content: String(args.prompt || '') },
+            ];
+            if (args.run_in_background) {
+                const task = tasks.create('agent', String(args.description || 'agent'));
+                (async () => {
+                    try {
+                        const { finalText } = await runAgentLoop({
+                            config: cfg(),
+                            messages: subMessages,
+                            tools: subAgentTools(),
+                            executeTool,
+                            hooks: {
+                                onText: (t) => tasks.append(task.id, t),
+                                onToolResult: (n, _a, ok, _o) => tasks.append(task.id, `\n[tool ${n}: ${ok ? 'ok' : 'err'}]\n`),
+                            },
+                        });
+                        tasks.append(task.id, `\n\n=== FINAL ===\n${finalText}`);
+                        tasks.finish(task.id, 'done');
+                    }
+                    catch (e) {
+                        tasks.append(task.id, `\n[error: ${e?.message || e}]`);
+                        tasks.finish(task.id, 'error');
+                    }
+                })();
+                return { ok: true, output: `Background sub-agent started: ${task.id}. Read its result with TaskOutput("${task.id}").` };
+            }
+            const { finalText } = await runAgentLoop({
+                config: cfg(),
+                messages: subMessages,
+                tools: subAgentTools(),
+                executeTool,
+            });
+            return { ok: true, output: finalText || '(sub-agent returned no text)' };
+        }
+        if (name === 'TaskOutput') {
+            const t = tasks.get(String(args.task_id));
+            if (!t)
+                return { ok: false, output: `No such task: ${args.task_id}. Use /tasks to list.` };
+            const body = t.output.slice(-9000) || '(no output yet)';
+            return { ok: true, output: `[${t.id}] ${t.kind} · ${t.status} · ${t.label}\n\n${body}` };
+        }
+        if (name === 'Read') {
+            const fp = args.file_path;
+            if (!fs.existsSync(fp))
+                return { ok: false, output: `Error: file does not exist: ${fp}` };
+            if (fs.statSync(fp).isDirectory())
+                return { ok: false, output: 'Error: path is a directory. Use an ls command via Bash to read a directory.' };
+            const raw = fs.readFileSync(fp, 'utf8');
+            readFiles.add(norm(fp));
+            if (raw.length === 0)
+                return { ok: true, output: '<system-reminder>File exists but has empty contents.</system-reminder>' };
+            const allLines = raw.split('\n');
+            const offset = Math.max(0, (Number(args.offset) || 1) - 1); // 1-tabanlı
+            const limit = Number(args.limit) || MAX_LINES_TO_READ;
+            const slice = allLines.slice(offset, offset + limit);
+            // cat -n formatı: sağa hizalı satır numarası + tab
+            const numbered = slice
+                .map((line, i) => `${String(offset + i + 1).padStart(6, ' ')}\t${line}`)
+                .join('\n');
+            return { ok: true, output: numbered.slice(0, 40000) };
+        }
+        if (name === 'Write') {
+            const fp = args.file_path;
+            if (fs.existsSync(fp) && !readFiles.has(norm(fp)))
+                return { ok: false, output: 'Error: existing file must be read first. Use the Read tool before overwriting.' };
+            fs.mkdirSync(path.dirname(path.resolve(fp)), { recursive: true });
+            fs.writeFileSync(fp, args.content ?? '');
+            readFiles.add(norm(fp));
+            return { ok: true, output: `Wrote ${fp} (${(args.content || '').length} chars)` };
+        }
+        if (name === 'Edit') {
+            const fp = args.file_path;
+            if (!fs.existsSync(fp))
+                return { ok: false, output: `Error: file does not exist: ${fp}` };
+            if (!readFiles.has(norm(fp)))
+                return { ok: false, output: 'Error: you must use the Read tool on this file before editing it.' };
+            const oldStr = String(args.old_string ?? '');
+            const newStr = String(args.new_string ?? '');
+            if (oldStr === newStr)
+                return { ok: false, output: 'Error: new_string must differ from old_string.' };
+            let c = fs.readFileSync(fp, 'utf8');
+            const count = oldStr ? c.split(oldStr).length - 1 : 0;
+            if (count === 0)
+                return { ok: false, output: 'Error: old_string not found in file.' };
+            if (count > 1 && !args.replace_all)
+                return {
+                    ok: false,
+                    output: `Error: old_string is not unique (${count} matches). Provide more surrounding context or set replace_all: true.`,
+                };
+            c = args.replace_all ? c.split(oldStr).join(newStr) : c.replace(oldStr, newStr);
+            fs.writeFileSync(fp, c);
+            return { ok: true, output: `Edited ${fp}${args.replace_all ? ` (${count} occurrences)` : ''}` };
+        }
+        if (name === 'Glob') {
+            const base = args.path || process.cwd();
+            const all = [];
+            walk(base, all);
+            const rx = globToRegex(args.pattern);
+            let matches = all.filter((f) => rx.test(f.replace(/\\/g, '/')));
+            // Değiştirilme zamanına göre sırala (yeni → eski), WormClaude gibi
+            matches = matches
+                .map((f) => { let m = 0; try {
+                m = fs.statSync(f).mtimeMs;
+            }
+            catch { } return { f, m }; })
+                .sort((a, b) => b.m - a.m)
+                .map((x) => x.f);
+            const truncated = matches.length > 100;
+            const shown = matches.slice(0, 100);
+            if (!shown.length)
+                return { ok: true, output: '(no matches)' };
+            return { ok: true, output: shown.join('\n') + (truncated ? '\n(results truncated to 100 files)' : '') };
+        }
+        if (name === 'Grep') {
+            const base = args.path && fs.existsSync(args.path) ? args.path : process.cwd();
+            const mode = args.output_mode || 'files_with_matches';
+            const flags = (args['-i'] ? 'i' : '') + (args.multiline ? 's' : '');
+            let rx;
+            try {
+                rx = new RegExp(args.pattern, flags + 'g');
+            }
+            catch (e) {
+                return { ok: false, output: `Error: invalid regex: ${e?.message || e}` };
+            }
+            const files = [];
+            if (fs.existsSync(base) && fs.statSync(base).isFile())
+                files.push(base);
+            else
+                walk(base, files);
+            // type / glob filtresi
+            let filtered = files;
+            if (args.type && TYPE_EXT[args.type]) {
+                const exts = TYPE_EXT[args.type];
+                filtered = filtered.filter((f) => exts.includes(path.extname(f).slice(1).toLowerCase()));
+            }
+            if (args.glob) {
+                const grx = globToRegex(args.glob);
+                filtered = filtered.filter((f) => grx.test(f.replace(/\\/g, '/')) || grx.test(path.basename(f)));
+            }
+            const showLineNo = args['-n'] !== false; // content modunda varsayılan true
+            const after = Number(args['-A'] ?? args['-C'] ?? args.context ?? 0);
+            const before = Number(args['-B'] ?? args['-C'] ?? args.context ?? 0);
+            const headLimit = args.head_limit === 0 ? Infinity : Number(args.head_limit) || 250;
+            const offset = Number(args.offset) || 0;
+            const reset = () => { rx.lastIndex = 0; return rx; };
+            const entries = [];
+            let fileCount = 0;
+            for (const f of filtered) {
+                let txt;
+                try {
+                    txt = fs.readFileSync(f, 'utf8');
+                }
+                catch {
+                    continue;
+                }
+                if (args.multiline) {
+                    // çok satırlı: tüm metinde ara
+                    if (mode === 'files_with_matches') {
+                        if (reset().test(txt)) {
+                            entries.push(f);
+                            fileCount++;
+                        }
+                    }
+                    else if (mode === 'count') {
+                        const n = (txt.match(rx) || []).length;
+                        if (n) {
+                            entries.push(`${f}:${n}`);
+                            fileCount++;
+                        }
+                    }
+                    else {
+                        const m = txt.match(rx);
+                        if (m) {
+                            entries.push(`${f}: ${m.length} match(es)`);
+                            fileCount++;
+                        }
+                    }
+                    continue;
+                }
+                const lines = txt.split('\n');
+                const lineRx = new RegExp(args.pattern, args['-i'] ? 'i' : '');
+                const hitIdx = [];
+                for (let i = 0; i < lines.length; i++)
+                    if (lineRx.test(lines[i]))
+                        hitIdx.push(i);
+                if (!hitIdx.length)
+                    continue;
+                fileCount++;
+                if (mode === 'files_with_matches') {
+                    entries.push(f);
+                    continue;
+                }
+                if (mode === 'count') {
+                    entries.push(`${f}:${hitIdx.length}`);
+                    continue;
+                }
+                // content modu
+                const printed = new Set();
+                for (const i of hitIdx) {
+                    for (let j = Math.max(0, i - before); j <= Math.min(lines.length - 1, i + after); j++) {
+                        if (printed.has(j))
+                            continue;
+                        printed.add(j);
+                        entries.push(showLineNo ? `${f}:${j + 1}: ${lines[j]}` : `${f}: ${lines[j]}`);
+                    }
+                }
+            }
+            const sliced = entries.slice(offset, offset + headLimit);
+            if (!sliced.length)
+                return { ok: true, output: '(no matches)' };
+            const note = entries.length > sliced.length ? `\n(${entries.length - sliced.length} more, raise head_limit to see)` : '';
+            return { ok: true, output: sliced.join('\n').slice(0, 30000) + note + `\n\n[${fileCount} file(s) with matches]` };
+        }
+        if (name === 'WebFetch') {
+            let url = String(args.url);
+            if (url.startsWith('http://'))
+                url = 'https://' + url.slice(7);
+            const res = await fetch(url, { signal: AbortSignal.timeout(20000) });
+            let txt = await res.text();
+            txt = txt
+                .replace(/<script[\s\S]*?<\/script>/gi, '')
+                .replace(/<style[\s\S]*?<\/style>/gi, '')
+                .replace(/<[^>]+>/g, ' ')
+                .replace(/\s+/g, ' ')
+                .trim();
+            const header = args.prompt ? `[prompt: ${String(args.prompt).slice(0, 200)}]\n\n` : '';
+            return { ok: true, output: header + (txt || '(empty)').slice(0, 15000) };
+        }
+        if (name === 'WebSearch') {
+            const q = encodeURIComponent(String(args.query || ''));
+            const max = Number(args.max_results) || 5;
+            const res = await fetch(`https://html.duckduckgo.com/html/?q=${q}`, {
+                headers: { 'User-Agent': 'Mozilla/5.0' }, signal: AbortSignal.timeout(20000),
+            });
+            const html = await res.text();
+            const out = [];
+            const re = /<a[^>]*class="result__a"[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/g;
+            let m;
+            while ((m = re.exec(html)) && out.length < max) {
+                let url = m[1];
+                const ud = url.match(/uddg=([^&]+)/);
+                if (ud)
+                    url = decodeURIComponent(ud[1]);
+                const title = m[2].replace(/<[^>]+>/g, '').replace(/\s+/g, ' ').trim();
+                out.push(`${out.length + 1}. ${title}\n   ${url}`);
+            }
+            return { ok: true, output: out.length ? out.join('\n') : '(sonuç yok)' };
+        }
+        if (name === 'TodoWrite') {
+            todosStore = Array.isArray(args.todos) ? args.todos : [];
+            const icon = (s) => (s === 'completed' ? '[x]' : s === 'in_progress' ? '[~]' : '[ ]');
+            const txt = todosStore.map((tdo) => `${icon(tdo.status)} ${tdo.content}`).join('\n');
+            return { ok: true, output: txt || '(boş)' };
+        }
+        if (name === 'PowerShell') {
+            let timeout = Number(args.timeout) || DEFAULT_BASH_TIMEOUT_MS;
+            if (timeout > MAX_BASH_TIMEOUT_MS)
+                timeout = MAX_BASH_TIMEOUT_MS;
+            const cmd = String(args.command).replace(/"/g, '\\"');
+            const out = execSync(`powershell -NoProfile -NonInteractive -Command "${cmd}"`, {
+                encoding: 'utf8', timeout, maxBuffer: 10 * 1024 * 1024, windowsHide: true,
+            });
+            return { ok: true, output: (out || '(no output)').slice(0, 20000) };
+        }
+        if (name === 'NotebookEdit') {
+            const fp = args.notebook_path;
+            if (!fs.existsSync(fp))
+                return { ok: false, output: `Error: file does not exist: ${fp}` };
+            const nb = JSON.parse(fs.readFileSync(fp, 'utf8'));
+            nb.cells = nb.cells || [];
+            const idx = Number(args.cell_index) || 0;
+            const mode = args.edit_mode || 'replace';
+            const src = String(args.new_source ?? '').split('\n').map((l, i, a) => (i < a.length - 1 ? l + '\n' : l));
+            if (mode === 'delete') {
+                if (!nb.cells[idx])
+                    return { ok: false, output: 'cell index out of range' };
+                nb.cells.splice(idx, 1);
+            }
+            else if (mode === 'insert') {
+                const cell = { cell_type: args.cell_type || 'code', metadata: {}, source: src };
+                if (cell.cell_type === 'code') {
+                    cell.outputs = [];
+                    cell.execution_count = null;
+                }
+                nb.cells.splice(idx, 0, cell);
+            }
+            else {
+                if (!nb.cells[idx])
+                    return { ok: false, output: 'cell index out of range' };
+                nb.cells[idx].source = src;
+            }
+            fs.writeFileSync(fp, JSON.stringify(nb, null, 1));
+            return { ok: true, output: `Notebook ${mode} @ cell ${idx} (${fp})` };
+        }
+        if (name === 'REPL') {
+            const lang = args.language;
+            const tmp = path.join(os.tmpdir(), `wc-repl-${Date.now()}.${lang === 'python' ? 'py' : 'js'}`);
+            fs.writeFileSync(tmp, String(args.code || ''));
+            try {
+                const cmd = lang === 'python' ? `python "${tmp}"` : `node "${tmp}"`;
+                const out = execSync(cmd, { encoding: 'utf8', timeout: 60000, maxBuffer: 10 * 1024 * 1024, windowsHide: true });
+                return { ok: true, output: (out || '(no output)').slice(0, 15000) };
+            }
+            catch (e) {
+                return { ok: false, output: ((e?.stdout || '') + (e?.stderr || e?.message || '')).slice(0, 15000) };
+            }
+            finally {
+                try {
+                    fs.unlinkSync(tmp);
+                }
+                catch { }
+            }
+        }
+        if (name === 'LSP') {
+            const base = args.path && fs.existsSync(args.path) ? args.path : process.cwd();
+            const sym = String(args.symbol);
+            const esc = sym.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            const defRe = new RegExp(`\\b(function|class|def|const|let|var|interface|type|enum|struct|fn|func)\\s+${esc}\\b`);
+            const refRe = new RegExp(`\\b${esc}\\b`);
+            const rx = args.action === 'definition' ? defRe : refRe;
+            const files = [];
+            walk(base, files);
+            const hits = [];
+            for (const f of files) {
+                if (hits.length > 100)
+                    break;
+                let txt;
+                try {
+                    txt = fs.readFileSync(f, 'utf8');
+                }
+                catch {
+                    continue;
+                }
+                const lines = txt.split('\n');
+                for (let i = 0; i < lines.length; i++) {
+                    if (rx.test(lines[i])) {
+                        hits.push(`${f}:${i + 1}: ${lines[i].trim().slice(0, 160)}`);
+                        if (hits.length > 100)
+                            break;
+                    }
+                }
+            }
+            return { ok: true, output: hits.length ? hits.join('\n') : '(bulunamadı)' };
+        }
+        if (name === 'Sleep') {
+            const s = Math.min(Math.max(0, Number(args.seconds) || 0), 60);
+            await new Promise((r) => setTimeout(r, s * 1000));
+            return { ok: true, output: `Slept ${s}s` };
+        }
+        if (name === 'Skill') {
+            const sk = getSkill(String(args.name));
+            if (!sk)
+                return { ok: false, output: `Unknown skill: ${args.name}` };
+            const prompt = buildSkillPrompt(sk, String(args.args || ''));
+            let tools = subAgentTools();
+            if (sk.tools && sk.tools.length)
+                tools = tools.filter((t) => sk.tools.includes(t.function.name));
+            const messages = [
+                { role: 'system', content: SUBAGENT_SYSTEM },
+                { role: 'user', content: prompt },
+            ];
+            const { finalText } = await runAgentLoop({ config: cfg(), messages, tools, executeTool });
+            return { ok: true, output: finalText || '(skill returned no text)' };
+        }
+        if (name.startsWith('mcp__'))
+            return await callMcpTool(name, args);
+        return { ok: false, output: `Unknown tool: ${name}` };
+    }
+    catch (e) {
+        return { ok: false, output: `Error: ${e?.message || String(e)}` };
+    }
+}