beast-agent 2.14.0 → 2.16.0

package/src/agent/opencode/prompts/trinity.txt

@@ -0,0 +1,97 @@
+You are opencode, an interactive CLI tool that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.
+
+# Tone and style
+You should be concise, direct, and to the point. When you run a non-trivial bash command, you should explain what the command does and why you are running it, to make sure the user understands what you are doing (this is especially important when you are running a command that will make changes to the user's system).
+Remember that your output will be displayed on a command line interface. Your responses can use GitHub-flavored markdown for formatting, and will be rendered in a monospace font using the CommonMark specification.
+Output text to communicate with the user; all text you output outside of tool use is displayed to the user. Only use tools to complete tasks. Never use tools like Bash or code comments as means to communicate with the user during the session.
+If you cannot or will not help the user with something, please do not say why or what it could lead to, since this comes across as preachy and annoying. Please offer helpful alternatives if possible, and otherwise keep your response to 1-2 sentences.
+Only use emojis if the user explicitly requests it. Avoid using emojis in all communication unless asked.
+IMPORTANT: You should minimize output tokens as much as possible while maintaining helpfulness, quality, and accuracy. Only address the specific query or task at hand, avoiding tangential information unless absolutely critical for completing the request. If you can answer in 1-3 sentences or a short paragraph, please do.
+IMPORTANT: You should NOT answer with unnecessary preamble or postamble (such as explaining your code or summarizing your action), unless the user asks you to.
+IMPORTANT: Keep your responses short, since they will be displayed on a command line interface. You MUST answer concisely with fewer than 4 lines (not including tool use or code generation), unless user asks for detail. Answer the user's question directly, without elaboration, explanation, or details. One word answers are best. Avoid introductions, conclusions, and explanations. You MUST avoid text before/after your response, such as "The answer is <answer>.", "Here is the content of the file..." or "Based on the information provided, the answer is..." or "Here is what I will do next...". Here are some examples to demonstrate appropriate verbosity:
+<example>
+user: 2 + 2
+assistant: 4
+</example>
+
+<example>
+user: what is 2+2?
+assistant: 4
+</example>
+
+<example>
+user: is 11 a prime number?
+assistant: Yes
+</example>
+
+<example>
+user: what command should I run to list files in the current directory?
+assistant: ls
+</example>
+
+<example>
+user: what command should I run to watch files in the current directory?
+assistant: [use the ls tool to list the files in the current directory, then read docs/commands in the relevant file to find out how to watch files]
+npm run dev
+</example>
+
+<example>
+user: How many golf balls fit inside a jetta?
+assistant: 150000
+</example>
+
+<example>
+user: what files are in the directory src/?
+assistant: [runs ls and sees foo.c, bar.c, baz.c]
+user: which file contains the implementation of foo?
+assistant: src/foo.c
+</example>
+
+<example>
+user: write tests for new feature
+assistant: [uses grep or glob to find where similar tests are defined, then read relevant files one at a time (one tool per message, wait for each result), then edit or write to add tests]
+</example>
+
+# Proactiveness
+You are allowed to be proactive, but only when the user asks you to do something. You should strive to strike a balance between:
+1. Doing the right thing when asked, including taking actions and follow-up actions
+2. Not surprising the user with actions you take without asking
+For example, if the user asks you how to approach something, you should do your best to answer their question first, and not immediately jump into taking actions.
+3. Do not add additional code explanation summary unless requested by the user. After working on a file, just stop, rather than providing an explanation of what you did.
+
+# Following conventions
+When making changes to files, first understand the file's code conventions. Mimic code style, use existing libraries and utilities, and follow existing patterns.
+- NEVER assume that a given library is available, even if it is well known. Whenever you write code that uses a library or framework, first check that this codebase already uses the given library. For example, you might look at neighboring files, or check the package.json (or cargo.toml, and so on depending on the language).
+- When you create a new component, first look at existing components to see how they're written; then consider framework choice, naming conventions, typing, and other conventions.
+- When you edit a piece of code, first look at the code's surrounding context (especially its imports) to understand the code's choice of frameworks and libraries. Then consider how to make the given change in a way that is most idiomatic.
+- Always follow security best practices. Never introduce code that exposes or logs secrets and keys. Never commit secrets or keys to the repository.
+
+# Code style
+- IMPORTANT: DO NOT ADD ***ANY*** COMMENTS unless asked
+
+# Doing tasks
+The user will primarily request you perform software engineering tasks. This includes solving bugs, adding new functionality, refactoring code, explaining code, and more. For these tasks the following steps are recommended:
+- Use the available search tools to understand the codebase and the user's query. Use one tool per message; after each result, decide the next step and call one tool again.
+- Implement the solution using all tools available to you
+- Verify the solution if possible with tests. NEVER assume specific test framework or test script. Check the README or search codebase to determine the testing approach.
+- VERY IMPORTANT: When you have completed a task, you MUST run the lint and typecheck commands (e.g. npm run lint, npm run typecheck, ruff, etc.) with Bash if they were provided to you to ensure your code is correct. If you are unable to find the correct command, ask the user for the command to run and if they supply it, proactively suggest writing it to AGENTS.md so that you will know to run it next time.
+NEVER commit changes unless the user explicitly asks you to. It is VERY IMPORTANT to only commit when explicitly asked, otherwise the user will feel that you are being too proactive.
+
+- Tool results and user messages may include <system-reminder> tags. <system-reminder> tags contain useful information and reminders. They are NOT part of the user's provided input or the tool result.
+
+# Tool usage policy
+- When doing file search, prefer to use the Task tool in order to reduce context usage.
+- Use exactly one tool per assistant message. After each tool call, wait for the result before continuing.
+- When the user's request is vague, use the question tool to clarify before reading files or making changes.
+- Avoid repeating the same tool with the same parameters once you have useful results. Use the result to take the next step (e.g. pick one match, read that file, then act); do not search again in a loop.
+
+You MUST answer concisely with fewer than 4 lines of text (not including tool use or code generation), unless user asks for detail.
+
+# Code References
+
+When referencing specific functions or pieces of code include the pattern `file_path:line_number` to allow the user to easily navigate to the source code location.
+
+<example>
+user: Where are errors from the client handled?
+assistant: Clients are marked as failed in the `connectToServer` function in src/services/process.ts:712.
+</example>

package/src/agent/opencode/prompts/webfetch.txt

@@ -0,0 +1,13 @@
+- Fetches content from a specified URL
+- Takes a URL and optional format as input
+- Fetches the URL content, converts to requested format (markdown by default)
+- Returns the content in the specified format
+- Use this tool when you need to retrieve and analyze web content
+
+Usage notes:
+  - IMPORTANT: if another tool is present that offers better web fetching capabilities, is more targeted to the task, or has fewer restrictions, prefer using that tool instead of this one.
+  - The URL must be a fully-formed valid URL
+  - HTTP URLs will be automatically upgraded to HTTPS
+  - Format options: "markdown" (default), "text", or "html"
+  - This tool is read-only and does not modify any files
+  - Results may be summarized if the content is very large

package/src/agent/opencode/prompts/websearch.txt

@@ -0,0 +1,14 @@
+- Search the web using the session's web search provider - performs real-time web searches and can scrape content from specific URLs
+- Provides up-to-date information for current events and recent data
+- Supports configurable result counts and returns the content from the most relevant websites
+- Use this tool for accessing information beyond knowledge cutoff
+- Searches are performed automatically within a single API call
+
+Usage notes:
+  - Supports live crawling modes when available: 'fallback' (backup if cached unavailable) or 'preferred' (prioritize live crawling)
+  - Search types when available: 'auto' (balanced), 'fast' (quick results), 'deep' (comprehensive search)
+  - Configurable context length for optimal LLM integration
+  - Domain filtering and advanced search options available
+
+The current year is {{year}}. You MUST use this year when searching for recent information or current events
+- Example: If the current year is 2026 and the user asks for "latest AI news", search for "AI news 2026", NOT "AI news 2025"

package/src/agent/opencode/prompts/write.txt

@@ -0,0 +1,8 @@
+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.
+- ALWAYS prefer editing existing files in the codebase. NEVER write new files unless explicitly required.
+- NEVER proactively create documentation files (*.md) or README files. Only create documentation files if explicitly requested by the User.
+- Only use emojis if the user explicitly requests it. Avoid writing emojis to files unless asked.

package/src/agent/opencode/systemprompt.js

@@ -0,0 +1,157 @@
+'use strict';
+
+/* ---------- opencode session/system.ts + reminders.ts portu (birebir) ----------
+   Beast Code (bcCode) oturumlarında system prompt artık TEK elle yazılmış
+   metin değil, opencode birleşimidir (prompt.ts:1257-1269):
+
+     system = [ ...environment(model),            → bu modül
+                ...instructions(AGENTS.md),        → engine._projectInstructions
+                ...(skills kataloğu),             → bu modül (skill/skill.ts fmt)
+                ...ajan tanımının promptu ]       → agents.js (explore vb.)
+
+   Ana prompt MODEL BAZLI seçilir (system.ts:27-49): gpt-4 ailesi, o1, o3 → beast.txt,
+   gpt* → gpt.txt (codex* → codex.txt), gemini-* → gemini.txt, claude →
+   anthropic.txt, kimi → kimi.txt, muse → meta.txt, trinity → trinity.txt,
+   diğer → default.txt.
+
+   Reminders (reminders.ts:15-90): plan ajanındaysa son user mesajına plan.txt
+   synthetic part'ı; geçmişte plan koşmuşsa ve şimdi build'se build-switch.txt
+   eklenir. Belleği kirletmemek için payload ÖNCESİ kopya mesajlara uygulanır
+   (her tur taze — opencode her turda DB'den yeniden yükleyip uygular). */
+
+const fs = require('fs');
+const path = require('path');
+const Permission = require('./permission');
+
+const PROMPT_DIR = path.join(__dirname, 'prompts');
+function loadPrompt(name) {
+  try {
+    let t = fs.readFileSync(path.join(PROMPT_DIR, name), 'utf8');
+    if (t.charCodeAt(0) === 0xfeff) t = t.slice(1); // BOM-strip
+    return t.replace(/\s+$/, '');
+  } catch {
+    return '';
+  }
+}
+
+const PROMPTS = {
+  beast: loadPrompt('beast.txt'),
+  gpt: loadPrompt('gpt.txt'),
+  codex: loadPrompt('codex.txt'),
+  anthropic: loadPrompt('anthropic.txt'),
+  gemini: loadPrompt('gemini.txt'),
+  kimi: loadPrompt('kimi.txt'),
+  meta: loadPrompt('meta.txt'),
+  trinity: loadPrompt('trinity.txt'),
+  default: loadPrompt('default.txt'),
+  plan: loadPrompt('plan.txt'),
+  buildSwitch: loadPrompt('build-switch.txt'),
+  explore: loadPrompt('explore.txt'),
+};
+
+/* opencode system.ts:27-49 — model-bazlı prompt seçimi (birebir) */
+function provider(modelId) {
+  const id = String(modelId || '');
+  if (id.includes('muse')) {
+    const name = id.includes('muse-glimmer') ? 'Muse Glimmer' : 'Muse Spark';
+    return [PROMPTS.meta.replaceAll('{{MODEL_NAME}}', name)];
+  }
+  if (id.includes('gpt-4') || id.includes('o1') || id.includes('o3')) return [PROMPTS.beast];
+  if (id.includes('gpt')) {
+    if (id.includes('codex')) return [PROMPTS.codex];
+    return [PROMPTS.gpt];
+  }
+  if (id.includes('gemini-')) return [PROMPTS.gemini];
+  if (id.includes('claude')) return [PROMPTS.anthropic];
+  if (id.toLowerCase().includes('trinity')) return [PROMPTS.trinity];
+  if (id.toLowerCase().includes('kimi')) return [PROMPTS.kimi];
+  return [PROMPTS.default];
+}
+
+/* opencode SystemPrompt.environment — model kimliği + <env> bloğu */
+function environment({ modelId, providerId, directory, worktree }) {
+  const isGit = (() => {
+    try {
+      return fs.existsSync(path.join(String(directory || ''), '.git')) ? 'yes' : 'no';
+    } catch {
+      return 'no';
+    }
+  })();
+  return [
+    [
+      `You are powered by the model named ${modelId}. The exact model ID is ${providerId}/${modelId}`,
+      `Here is some useful information about the environment you are running in:`,
+      `<env>`,
+      `  Working directory: ${directory}`,
+      `  Workspace root folder: ${worktree}`,
+      `  Is directory a git repo: ${isGit}`,
+      `  Platform: ${process.platform}`,
+      `  Today's date: ${new Date().toDateString()}`,
+      `</env>`,
+    ].join('\n'),
+  ];
+}
+
+/* opencode skill/skill.ts fmt (verbose) — skills.js scan() listesini
+   opencode katalog biçimine basar */
+function skillsCatalog(skills) {
+  const described = (skills || []).filter((s) => s && s.description);
+  if (!described.length) return undefined;
+  return [
+    'Skills provide specialized instructions and workflows for specific tasks.',
+    'Use the skill tool to load a skill when a task matches its description.',
+    '<available_skills>',
+    ...described
+      .slice()
+      .sort((a, b) => String(a.name).localeCompare(String(b.name)))
+      .flatMap((s) => [
+        '  <skill>',
+        `    <name>${s.name}</name>`,
+        `    <description>${s.description}</description>`,
+        `    <location>${s.path}</location>`,
+        '  </skill>',
+      ]),
+    '</available_skills>',
+  ].join('\n');
+}
+
+/* opencode SystemPrompt.skills — ajanın skill izni yoksa katalog gösterilmez */
+function skills(ruleset, scanFn) {
+  if (Permission.disabled(['skill'], ruleset).has('skill')) return undefined;
+  try {
+    return skillsCatalog(scanFn());
+  } catch {
+    return undefined;
+  }
+}
+
+/* opencode SessionReminders.apply — synthetic part yerine son user mesajının
+   KOPIASINA metin ekler; session.messages asla değişmez (her tur taze uygulanır).
+   wasPlan: bu oturumda daha önce plan ajanı koştu mu (engine takip eder). */
+function applyReminders(messages, agent, wasPlan) {
+  const msgs = (messages || []).slice();
+  const lastUserIdx = msgs.findLastIndex ? msgs.findLastIndex((m) => m.role === 'user') : -1;
+  if (lastUserIdx < 0 || !agent) return msgs;
+  const adds = [];
+  if (agent.name === 'plan') adds.push(PROMPTS.plan);
+  if (wasPlan && agent.name === 'build') adds.push(PROMPTS.buildSwitch);
+  if (!adds.length) return msgs;
+  const base = msgs[lastUserIdx];
+  const baseText =
+    typeof base.content === 'string' ? base.content : '';
+  msgs[lastUserIdx] = {
+    ...base,
+    content: (baseText ? baseText + '\n\n' : '') + adds.join('\n\n'),
+  };
+  return msgs;
+}
+
+module.exports = {
+  PROMPTS,
+  provider,
+  environment,
+  skills,
+  skillsCatalog,
+  applyReminders,
+  loadPrompt,
+};

package/src/agent/opencode/toolmap.js

@@ -0,0 +1,316 @@
+'use strict';
+
+/* ---------- opencode tool seti → Beast araç köprüsü ----------
+   Beast Code (bcCode) oturumlarında model opencode'un ARAÇ DİLİYLE konuşur:
+   read · edit · write · bash · glob · grep · list · fetch · websearch ·
+   todowrite · task · skill  (opencode builtin registry sırası)
+
+   Tanımlar opencode-dev'den birebir: açıklama metinleri tool/*.txt,
+   parametre şemaları opencode Schema.Struct karşılıkları (JSON Schema).
+   execMap() çağrıyı Beast'in yerleşik aracına çevirir — implementasyon
+   değişmez, modelin gördüğü dünya opencode olur. */
+
+const fs = require('fs');
+const path = require('path');
+
+const PROMPT_DIR = path.join(__dirname, 'prompts');
+function loadPrompt(name) {
+  try {
+    let t = fs.readFileSync(path.join(PROMPT_DIR, name), 'utf8');
+    if (t.charCodeAt(0) === 0xfeff) t = t.slice(1); // BOM-strip
+    return t.replace(/\s+$/, '') + '\n';
+  } catch {
+    return '';
+  }
+}
+
+/* opencode tool/shell/prompt.ts Windows (PowerShell) açıklaması — Beast
+   değerleriyle: varsayılan timeout 120s, 2000 satır / 50KB tavan, tam
+   çıktı geçici dosyaya düşer (Beast run_command zaten bu disiplinde) */
+function bashDescription() {
+  const defaultTimeoutMs = 120000;
+  const maxLines = 2000;
+  const maxBytes = '50KB';
+  return `Executes a given PowerShell command in a persistent shell session.
+
+## Command Execution
+
+Before executing the command, please follow these steps:
+  1. If the command will create new directories or files, first use \`Test-Path -LiteralPath <parent>\` to verify the parent directory exists and is the correct location
+  2. If the command will modify or delete files, first verify the paths are correct
+  3. For commands expected to create new directories or files, verify the expected file/folder location is inside the working directory
+
+After ensuring proper quoting, execute the command.
+  - Capture the output of the command.
+
+## Usage Notes
+
+  - The command argument is required.
+  - You can specify an optional timeout in milliseconds. If not specified, commands will time out after ${defaultTimeoutMs}ms.
+  - If the output exceeds ${maxLines} lines or ${maxBytes} bytes, it will be truncated and the full output will be written to a file. You can use Read with offset/limit to read specific sections or Grep to search the full content. Do NOT use \`Select-Object -First\`, \`Select-Object -Last\`, or other truncation commands to limit output; the full output will already be captured to a file for more precise searching.
+  - Avoid using Shell with PowerShell file/content cmdlets unless explicitly instructed or when these cmdlets are truly necessary for the task. Instead, always prefer using the dedicated tools for reading, searching, and editing files:
+    - Read: Reading and analyzing file contents (with line numbers)
+    - Edit: Making targeted changes to specific sections of files
+    - Write: Creating new files from scratch
+    - Grep: Searching file contents with regex patterns
+    - Glob: Finding files by patterns (e.g., "src/**/*.ts")
+  - When issuing multiple commands:
+    - If the commands are independent and can run in parallel, make multiple bash tool calls in a single message. For example, if you need to run "git status" and "git diff", send a single message with two bash tool calls in parallel.
+    - Use ';' only when you need to run commands sequentially but don't care if earlier commands fail
+    - If the commands depend on each other and must run sequentially, avoid '&&' in this shell because Windows PowerShell (5.1) does not support it. Use PowerShell conditionals such as \`cmd1; if ($?) { cmd2 }\` when later commands must depend on earlier success.
+    - DO NOT use newlines to separate commands (newlines are ok in quoted strings)
+  - The shell is PERSISTENT: working directory and environment variables are preserved between calls.
+  - Commands run in Windows PowerShell (5.1).`;
+}
+
+/* opencode tool şemaları — Schema.Struct karşılığı JSON Schema'lar */
+const DEFS = () => [
+  {
+    name: 'bash',
+    description: bashDescription(),
+    parameters: {
+      type: 'object',
+      properties: {
+        command: { type: 'string', description: 'The command to execute' },
+        timeout: { type: 'integer', description: 'Optional timeout in milliseconds' },
+      },
+      required: ['command'],
+    },
+  },
+  {
+    name: 'read',
+    description: loadPrompt('read.txt'),
+    parameters: {
+      type: 'object',
+      properties: {
+        filePath: { type: 'string', description: 'The absolute path to the file or directory to read' },
+        offset: { type: 'integer', description: 'The line number to start reading from (1-indexed)' },
+        limit: { type: 'integer', description: 'The maximum number of lines to read (defaults to 2000)' },
+      },
+      required: ['filePath'],
+    },
+  },
+  {
+    name: 'edit',
+    description: loadPrompt('edit.txt'),
+    parameters: {
+      type: 'object',
+      properties: {
+        filePath: { type: 'string', description: 'The absolute path to the file to modify' },
+        oldString: { type: 'string', description: 'The text to replace' },
+        newString: { type: 'string', description: 'The text to replace it with (must be different from oldString)' },
+        replaceAll: { type: 'boolean', description: 'Replace all occurrences of oldString (default false)' },
+      },
+      required: ['filePath', 'oldString', 'newString'],
+    },
+  },
+  {
+    name: 'write',
+    description: loadPrompt('write.txt'),
+    parameters: {
+      type: 'object',
+      properties: {
+        filePath: { type: 'string', description: 'The absolute path to the file to write (will create the file if it does not exist, will overwrite if it does)' },
+        content: { type: 'string', description: 'The content to write' },
+      },
+      required: ['filePath', 'content'],
+    },
+  },
+  {
+    name: 'glob',
+    description: loadPrompt('glob.txt'),
+    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'],
+    },
+  },
+  {
+    name: 'grep',
+    description: loadPrompt('grep.txt'),
+    parameters: {
+      type: 'object',
+      properties: {
+        pattern: { type: 'string', description: 'The regex pattern to search for in file contents' },
+        path: { type: 'string', description: 'The directory to search in. Defaults to the current working directory.' },
+        include: { type: 'string', description: 'File pattern to include in the search (e.g. "*.js", "*.{ts,tsx}")' },
+      },
+      required: ['pattern'],
+    },
+  },
+  {
+    name: 'list',
+    description: 'List files and directories in a given path. Returns entries sorted by name (directories first, then files), with type indicator and size.',
+    parameters: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'The directory path to list. Defaults to the current working directory.' },
+      },
+    },
+  },
+  {
+    name: 'webfetch',
+    description: loadPrompt('webfetch.txt'),
+    parameters: {
+      type: 'object',
+      properties: {
+        url: { type: 'string', description: 'The URL to fetch' },
+        format: { type: 'string', enum: ['text', 'markdown', 'html'], description: 'The format to return the content in (text, markdown, or html). Defaults to markdown.' },
+        timeout: { type: 'integer', description: 'Optional timeout in seconds (max 120)' },
+        max_chars: { type: 'integer', description: 'Optional maximum characters to return' },
+      },
+      required: ['url'],
+    },
+  },
+  {
+    name: 'websearch',
+    description: loadPrompt('websearch.txt'),
+    parameters: {
+      type: 'object',
+      properties: {
+        query: { type: 'string', description: 'Websearch query' },
+        numResults: { type: 'integer', description: 'Number of search results to return (default: 8)' },
+        type: { type: 'string', enum: ['auto', 'fast', 'deep'], description: "Search type - 'auto': balanced search (default), 'fast': quick results, 'deep': comprehensive search" },
+      },
+      required: ['query'],
+    },
+  },
+  {
+    name: 'todowrite',
+    description: loadPrompt('todowrite.txt'),
+    parameters: {
+      type: 'object',
+      properties: {
+        todos: {
+          type: 'array',
+          description: 'The updated todo list',
+          items: {
+            type: 'object',
+            properties: {
+              content: { type: 'string', description: 'Brief description of the task' },
+              status: { type: 'string', enum: ['pending', 'in_progress', 'completed', 'cancelled'], description: 'Current status of the task' },
+              priority: { type: 'string', enum: ['high', 'medium', 'low'], description: 'Priority level of the task' },
+            },
+            required: ['content', 'status'],
+          },
+        },
+      },
+      required: ['todos'],
+    },
+  },
+  {
+    name: 'task',
+    description: loadPrompt('task.txt'),
+    parameters: {
+      type: 'object',
+      properties: {
+        description: { type: 'string', description: 'A short description of the task (max 80 chars)' },
+        prompt: { type: 'string', description: 'The full task description for the subagent to execute' },
+        subagent_type: { type: 'string', enum: ['general', 'explore'], description: 'Type of subagent to launch (options: explore, general)' },
+      },
+      required: ['description', 'prompt', 'subagent_type'],
+    },
+  },
+  {
+    name: 'skill',
+    description: loadPrompt('skill.txt'),
+    parameters: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'The name of the skill from available_skills' },
+      },
+      required: ['name'],
+    },
+  },
+  {
+    /* Beast Sandbox'a özgü: UZUN SÜRELİ süreçleri (dev server vb.) ÇALIŞTIR
+       paneline devreder — tur BLOKLAMAZ. panel_run izni yalnız sandbox
+       ajanında allow edilir (agents.js); BC build/plan'da gizlidir. */
+    name: 'panel_run',
+    description:
+      'Run a LONG-RUNNING process (dev server, background service) in the managed RUN panel instead of the blocking shell. The turn does not wait for it to finish; output streams live in the panel and can be stopped by the user. Use this instead of starting servers with bash — a blocking bash call would stall the whole job. Only ONE process runs at a time.',
+    parameters: {
+      type: 'object',
+      properties: {
+        command: { type: 'string', description: 'The command to run in the panel' },
+      },
+      required: ['command'],
+    },
+  },
+];
+
+/* OpenAI function-call formatına çevirir (engine TOOLS formatı) */
+function definitions() {
+  return DEFS().map((d) => ({ type: 'function', function: d }));
+}
+
+const TO_BUILTIN = {
+  bash: 'run_command',
+  read: 'read_file',
+  edit: 'edit_file',
+  write: 'write_file',
+  glob: 'glob',
+  grep: 'grep',
+  list: 'list_dir',
+  webfetch: 'webfetch',
+  websearch: 'web_search',
+  todowrite: 'todo_write',
+  task: 'delegate_task',
+  panel_run: 'panel_run',
+};
+
+/* opencode parametreleri → Beast araç parametreleri */
+function execMap(name, args) {
+  const a = args || {};
+  switch (name) {
+    case 'read':
+      return { name: 'read_file', args: { path: a.filePath, offset: a.offset, limit: a.limit } };
+    case 'edit':
+      return {
+        name: 'edit_file',
+        args: { path: a.filePath, old_string: a.oldString, new_string: a.newString, replace_all: a.replaceAll === true },
+      };
+    case 'write':
+      return { name: 'write_file', args: { path: a.filePath, content: a.content } };
+    case 'bash':
+      return { name: 'run_command', args: { command: a.command, timeout_ms: a.timeout } };
+    case 'list':
+      return { name: 'list_dir', args: { path: a.path } };
+    case 'webfetch':
+      return { name: 'webfetch', args: { url: a.url, format: a.format, timeout: a.timeout, max_chars: a.max_chars } };
+    case 'websearch':
+      return { name: 'web_search', args: { query: a.query, max_results: a.numResults || a.max_results } };
+    case 'todowrite':
+      return { name: 'todo_write', args: { items: (a.todos || []).map(opencodeTodoToItem) } };
+    case 'task':
+      return {
+        name: 'delegate_task',
+        args: { task: a.prompt || a.description, context: a.description || '', subagent_type: a.subagent_type },
+      };
+    default:
+      return { name: TO_BUILTIN[name] || name, args: a };
+  }
+}
+
+/* opencode Todo.Info {content, status, priority} → Beast iç depo {title, status}
+   opencode durum makinesi: pending → in_progress → completed | cancelled
+   Beast iç durumu: pending | active | done */
+const OC_TODO_STATUS = { pending: 'pending', in_progress: 'active', completed: 'done', cancelled: 'done' };
+function opencodeTodoToItem(t) {
+  const it = t || {};
+  return {
+    title: String(it.content ?? '').replace(/\s+/g, ' ').trim().slice(0, 120),
+    status: OC_TODO_STATUS[String(it.status || 'pending')] || 'pending',
+  };
+}
+
+/* BC oturumunda modele sunulan opencode araç adları (permission filtresinden
+   önce tam set — opencode registry builtin sırası) */
+function names() {
+  return DEFS().map((d) => d.name);
+}
+
+module.exports = { definitions, names, execMap, TO_BUILTIN, opencodeTodoToItem };