beast-agent 2.14.0 → 2.16.0

package/src/agent/financetools.js

@@ -0,0 +1,307 @@
+'use strict';
+
+/* Beast Finance — MT5 ajan araçları.
+   Handler'lar main süreçteki mt5bridge singleton'ına bağlanır; işlem açan
+   araçlar settings.finance.allowTrading / maxLot / maxPositions ile sınırlanır.
+   main tarafı setConfig/setNotify ile ayar ve bildirim kancasını enjekte eder. */
+
+const mt5 = require('../mt5bridge');
+
+const NAMES = [
+  'mt5_status',
+  'mt5_account',
+  'mt5_market',
+  'mt5_positions',
+  'mt5_orders',
+  'mt5_history',
+  'mt5_trade',
+  'mt5_close',
+  'mt5_modify',
+  'mt5_pending',
+  'mt5_cancel',
+];
+
+let getCfg = () => ({ allowTrading: false, maxLot: 0.1, maxPositions: 3, symbols: [] });
+let notify = () => {};
+
+function setConfig(fn) {
+  if (typeof fn === 'function') getCfg = fn;
+}
+
+function setNotify(fn) {
+  if (typeof fn === 'function') notify = fn;
+}
+
+function clampLot(v, maxLot) {
+  const n = Number(v);
+  if (!isFinite(n) || n <= 0) return 0;
+  return Math.min(n, maxLot);
+}
+
+async function bcall(method, params, timeoutMs) {
+  const r = await mt5.call(method, params, timeoutMs);
+  if (!r || r.ok !== true) throw new Error((r && r.error) || 'MT5 hatası');
+  return r.data;
+}
+
+function noteTrade(kind, data) {
+  try { notify({ kind, data, at: Date.now() }); } catch {}
+}
+
+function notConnected() {
+  return { ok: false, error: 'MT5 köprüsü bağlı değil — terminal açık mı? (panelde ⟳ ile yeniden bağlan)' };
+}
+
+const definitions = NAMES.map((name) => {
+  const specs = {
+    mt5_status: {
+      description:
+        'MT5 (MetaTrader 5) köprü durumunu döndürür: köprü çalışıyor mu, terminale bağlı mı, terminal/hesap özeti. Her finance turunda VEYA bağlantı sorunlarında ilk çağrı.',
+      parameters: { type: 'object', properties: {} },
+    },
+    mt5_account: {
+      description:
+        'MT5 hesap özeti: bakiye, özkaynak (equity), yüzen kâr/zarar, marj, serbest marj, marj seviyesi, kaldıraç, para birimi, hesap no/sunucu.',
+      parameters: { type: 'object', properties: {} },
+    },
+    mt5_market: {
+      description:
+        'Verilen semboller için canlı fiyat: bid/ask, spread, digit, point. symbols verilmezse izleme listesi (watchlist) kullanılır. Örn: ["EURUSD","XAUUSD"].',
+      parameters: {
+        type: 'object',
+        properties: {
+          symbols: { type: 'array', items: { type: 'string' }, description: 'Sembol listesi (boşsa watchlist)' },
+        },
+      },
+    },
+    mt5_positions: {
+      description: 'Açık pozisyonlar: ticket, sembol, yön, lot, açılış fiyatı, güncel fiyat, SL/TP, yüzen kâr/zarar, açılış zamanı.',
+      parameters: { type: 'object', properties: {} },
+    },
+    mt5_orders: {
+      description: 'Bekleyen emirler (pending orders): ticket, sembol, tip (limit/stop), lot, fiyat, SL/TP.',
+      parameters: { type: 'object', properties: {} },
+    },
+    mt5_history: {
+      description: 'Kapanmış işlemler (deals) özeti: son N günde kapanan pozisyonlar, kâr/zarar, komisyon, swap. days=1 → son 24 saat.',
+      parameters: {
+        type: 'object',
+        properties: { days: { type: 'number', description: 'Kaç gün geriye bakılsın (varsayılan 1, en fazla 90)' } },
+      },
+    },
+    mt5_trade: {
+      description:
+        'PİYASA EMRİ AÇAR: mt5_trade {symbol, side:"buy"|"sell", volume, sl?, tp?, comment?}. Lot limiti ve max pozisyon sayısı sistem tarafından zorlanır. Otomatik işlem anahtarı kapalıysa reddedilir. SL/TP vermek ŞIDDETLİ önerilir.',
+      parameters: {
+        type: 'object',
+        properties: {
+          symbol: { type: 'string', description: 'Örn: EURUSD' },
+          side: { type: 'string', enum: ['buy', 'sell'] },
+          volume: { type: 'number', description: 'Lot (max lot sınırına tabi)' },
+          sl: { type: 'number', description: 'Stop loss fiyatı (0 = yok)' },
+          tp: { type: 'number', description: 'Take profit fiyatı (0 = yok)' },
+          comment: { type: 'string', description: 'Kısa işlem notu' },
+        },
+        required: ['symbol', 'side', 'volume'],
+      },
+    },
+    mt5_close: {
+      description: 'Açık pozisyonu kapatır: mt5_close {ticket, volume?}. volume verilirse kısmi kapatır. Risk yönetimi için kullanılır.',
+      parameters: {
+        type: 'object',
+        properties: {
+          ticket: { type: 'number', description: 'Pozisyon ticket no' },
+          volume: { type: 'number', description: 'Kapatılacak lot (boşsa tamamı)' },
+        },
+        required: ['ticket'],
+      },
+    },
+    mt5_modify: {
+      description: 'Pozisyonun SL/TP seviyelerini günceller: mt5_modify {ticket, sl, tp}. SL’siz pozisyon bırakmamak için kullan.',
+      parameters: {
+        type: 'object',
+        properties: {
+          ticket: { type: 'number' },
+          sl: { type: 'number', description: 'Yeni SL (0 = kaldır)' },
+          tp: { type: 'number', description: 'Yeni TP (0 = kaldır)' },
+        },
+        required: ['ticket'],
+      },
+    },
+    mt5_pending: {
+      description:
+        'BEKLEYEN EMİR koyar: mt5_pending {symbol, type:"buy_limit"|"sell_limit"|"buy_stop"|"sell_stop", volume, price, sl?, tp?}. Otomatik işlem anahtarına tabidir.',
+      parameters: {
+        type: 'object',
+        properties: {
+          symbol: { type: 'string' },
+          type: { type: 'string', enum: ['buy_limit', 'sell_limit', 'buy_stop', 'sell_stop'] },
+          volume: { type: 'number' },
+          price: { type: 'number' },
+          sl: { type: 'number' },
+          tp: { type: 'number' },
+        },
+        required: ['symbol', 'type', 'volume', 'price'],
+      },
+    },
+    mt5_cancel: {
+      description: 'Bekleyen emri iptal eder: mt5_cancel {ticket}.',
+      parameters: {
+        type: 'object',
+        properties: { ticket: { type: 'number' } },
+        required: ['ticket'],
+      },
+    },
+  };
+  const s = specs[name];
+  return { type: 'function', function: { name, ...s } };
+});
+
+const handlers = {
+  async mt5_status() {
+    const st = mt5.status();
+    return { ok: true, ...st };
+  },
+  async mt5_account() {
+    if (!mt5.running) return notConnected();
+    const data = await bcall('account', {}, 8000);
+    return { ok: true, ...data };
+  },
+  async mt5_market(args) {
+    if (!mt5.running) return notConnected();
+    const cfg = getCfg();
+    let syms = Array.isArray(args.symbols) ? args.symbols.map((s) => String(s).trim()).filter(Boolean) : [];
+    if (!syms.length) syms = Array.isArray(cfg.symbols) ? cfg.symbols : [];
+    const data = await bcall('symbols', { symbols: syms }, 10000);
+    return { ok: true, symbols: data && data.symbols ? data.symbols : [] };
+  },
+  async mt5_positions() {
+    if (!mt5.running) return notConnected();
+    const data = await bcall('positions', {}, 8000);
+    const list = (data && data.positions) || [];
+    return { ok: true, count: list.length, positions: list };
+  },
+  async mt5_orders() {
+    if (!mt5.running) return notConnected();
+    const data = await bcall('orders', {}, 8000);
+    const list = (data && data.orders) || [];
+    return { ok: true, count: list.length, orders: list };
+  },
+  async mt5_history(args) {
+    if (!mt5.running) return notConnected();
+    let days = Number(args.days);
+    if (!isFinite(days) || days <= 0) days = 1;
+    days = Math.min(days, 90);
+    const data = await bcall('deals', { days }, 12000);
+    const deals = (data && data.deals) || [];
+    /* hızlı özet: giriş/çıkış eşleşmesi yapmadan net realized P/L */
+    let profit = 0;
+    let wins = 0;
+    let losses = 0;
+    for (const dl of deals) {
+      const p = Number(dl.profit) || 0;
+      if (String(dl.entry) === '1' || dl.entry === 1 || p !== 0) {
+        profit += p + (Number(dl.swap) || 0) + (Number(dl.commission) || 0);
+        if (p > 0) wins++;
+        else if (p < 0) losses++;
+      }
+    }
+    return {
+      ok: true,
+      days,
+      count: deals.length,
+      netProfit: Math.round(profit * 100) / 100,
+      wins,
+      losses,
+      deals: deals.slice(-60),
+    };
+  },
+  async mt5_trade(args) {
+    const cfg = getCfg();
+    if (!cfg.allowTrading) {
+      return { ok: false, error: 'Otomatik işlem KAPALI — analiz/öneri modundasın. İşlem önerisini yaz, açma.' };
+    }
+    if (!mt5.running) return notConnected();
+    const side = String(args.side || '').toLowerCase();
+    if (side !== 'buy' && side !== 'sell') return { ok: false, error: "side 'buy' veya 'sell' olmalı" };
+    const symbol = String(args.symbol || '').trim().toUpperCase();
+    if (!symbol) return { ok: false, error: 'symbol gerekli' };
+    const maxLot = Number(cfg.maxLot) || 0.1;
+    const vol = clampLot(args.volume, maxLot);
+    if (!vol) return { ok: false, error: 'volume gerekli (pozitif sayı)' };
+    const pos = await bcall('positions', {}, 8000);
+    const maxPos = Number(cfg.maxPositions) || 3;
+    const openCount = ((pos && pos.positions) || []).length;
+    if (openCount >= maxPos) {
+      return { ok: false, error: `max eşzamanlı pozisyon dolu (${openCount}/${maxPos}) — önce bir pozisyon kapat` };
+    }
+    const data = await bcall('market', {
+      symbol,
+      side,
+      volume: vol,
+      sl: Number(args.sl) || 0,
+      tp: Number(args.tp) || 0,
+      deviation: 20,
+      comment: String(args.comment || 'Beast').slice(0, 26),
+    }, 20000);
+    noteTrade('trade', { symbol, side, volume: vol, result: data && data.result });
+    return { ok: true, opened: { symbol, side, volume: vol, sl: Number(args.sl) || 0, tp: Number(args.tp) || 0 }, result: data && data.result };
+  },
+  async mt5_close(args) {
+    const cfg = getCfg();
+    if (!mt5.running) return notConnected();
+    const ticket = Number(args.ticket);
+    if (!ticket) return { ok: false, error: 'ticket gerekli' };
+    let vol = Number(args.volume) || 0;
+    if (vol > 0) {
+      const maxLot = Number(cfg.maxLot) || 0.1;
+      if (vol > maxLot) return { ok: false, error: `kısmi kapatma lotu limiti aşıyor (max ${maxLot})` };
+    }
+    const data = await bcall('close', { ticket, volume: vol || 0 }, 20000);
+    noteTrade('close', { ticket, volume: vol || 'all', result: data && data.result });
+    return { ok: true, result: data && data.result };
+  },
+  async mt5_modify(args) {
+    if (!mt5.running) return notConnected();
+    const ticket = Number(args.ticket);
+    if (!ticket) return { ok: false, error: 'ticket gerekli' };
+    const data = await bcall('modify', {
+      ticket,
+      sl: Number(args.sl) || 0,
+      tp: Number(args.tp) || 0,
+    }, 20000);
+    noteTrade('modify', { ticket, sl: Number(args.sl) || 0, tp: Number(args.tp) || 0 });
+    return { ok: true, result: data && data.result };
+  },
+  async mt5_pending(args) {
+    const cfg = getCfg();
+    if (!cfg.allowTrading) {
+      return { ok: false, error: 'Otomatik işlem KAPALI — bekleyen emir de açılamaz. Öneriyi yaz.' };
+    }
+    if (!mt5.running) return notConnected();
+    const maxLot = Number(cfg.maxLot) || 0.1;
+    const vol = clampLot(args.volume, maxLot);
+    if (!vol) return { ok: false, error: 'volume gerekli' };
+    const data = await bcall('pending', {
+      symbol: String(args.symbol || '').trim().toUpperCase(),
+      type: String(args.type || '').toLowerCase(),
+      volume: vol,
+      price: Number(args.price) || 0,
+      sl: Number(args.sl) || 0,
+      tp: Number(args.tp) || 0,
+      comment: String(args.comment || 'Beast').slice(0, 26),
+    }, 20000);
+    noteTrade('pending', { symbol: args.symbol, type: args.type, volume: vol });
+    return { ok: true, result: data && data.result };
+  },
+  async mt5_cancel(args) {
+    if (!mt5.running) return notConnected();
+    const ticket = Number(args.ticket);
+    if (!ticket) return { ok: false, error: 'ticket gerekli' };
+    const data = await bcall('cancel', { ticket }, 20000);
+    noteTrade('cancel', { ticket });
+    return { ok: true, result: data && data.result };
+  },
+};
+
+module.exports = { definitions, handlers, NAMES, setConfig, setNotify };

package/src/agent/opencode/agents.js

@@ -0,0 +1,161 @@
+'use strict';
+
+/* ---------- opencode agent/agent.ts portu (birebir) ----------
+   Beast Code (bcCode) oturumları artık "mod" değil AJAN koşar:
+   build (varsayılan) · plan (salt-okur) · general/explore (task alt-ajanları).
+
+   Agent.Info şeması (opencode):
+     { name, description, mode: 'subagent'|'primary'|'all', hidden, temperature,
+       permission: Ruleset, model?, prompt?, steps?, options }
+
+   Permission birleşim sırası (opencode birebir): defaults → ajan özel → user.
+   Son eşleşen kural kazanır (permission.evaluate findLast). */
+
+const path = require('path');
+const Permission = require('./permission');
+
+/* opencode SystemPrompt.environment'daki gibi runtime klasörleri ajan
+   kurallarına basar: plan ajanı workspace içindeki .opencode/plans/*.md'ye
+   yazabilir (opencode: Global.Path.data/plans + .opencode/plans/*.md allow) */
+function planRules(worktree) {
+  const ws = String(worktree || '');
+  return Permission.fromConfig({
+    question: 'allow',
+    plan_exit: 'allow',
+    task: { general: 'deny' },
+    external_directory: { '*': 'ask' },
+    edit: {
+      '*': 'deny',
+      [path.join('.opencode', 'plans', '*.md')]: 'allow',
+      ...(ws ? { [path.join(ws, '.opencode', 'plans', '*.md')]: 'allow' } : {}),
+    },
+  });
+}
+
+/* opencode agent.ts defaults (satır 119-136) — birebir.
+   Beast'te "question" aracı yok; kural etkisiz kalır, dokunma.
+   panel_run: Beast'e özgü (Sandbox ÇALIŞTIR paneli) — default DENY,
+   yalnız sandbox ajanında allow edilir (opencode custom-agent deseni). */
+function defaultRuleset() {
+  return Permission.fromConfig({
+    '*': 'allow',
+    doom_loop: 'ask',
+    external_directory: { '*': 'ask' },
+    question: 'deny',
+    plan_enter: 'deny',
+    plan_exit: 'deny',
+    panel_run: 'deny',
+    // github/gitignore Node.gitignore desenine uygun .env koruması
+    read: {
+      '*': 'allow',
+      '*.env': 'ask',
+      '*.env.*': 'ask',
+      '*.env.example': 'allow',
+    },
+  });
+}
+
+/* Yerleşik ajanlar — opencode agent.ts:140-265 birebir (promptlar
+   opencode-dev'den kopyalandı: prompts/explore.txt) */
+function build(opts = {}) {
+  const defaults = defaultRuleset();
+  const user = Permission.fromConfig(opts.user || {});
+  return {
+    build: {
+      name: 'build',
+      description: 'The default agent. Executes tools based on configured permissions.',
+      options: {},
+      permission: Permission.merge(
+        defaults,
+        Permission.fromConfig({ question: 'allow', plan_enter: 'allow' }),
+        user
+      ),
+      mode: 'primary',
+      native: true,
+    },
+    plan: {
+      name: 'plan',
+      description: 'Plan mode. Disallows all edit tools.',
+      options: {},
+      permission: Permission.merge(defaults, planRules(opts.worktree), user),
+      mode: 'primary',
+      native: true,
+    },
+    general: {
+      name: 'general',
+      description:
+        'General-purpose agent for researching complex questions and executing multi-step tasks. Use this agent to execute multiple units of work in parallel.',
+      permission: Permission.merge(defaults, Permission.fromConfig({ todowrite: 'deny' }), user),
+      options: {},
+      mode: 'subagent',
+      native: true,
+    },
+    explore: {
+      name: 'explore',
+      permission: Permission.merge(
+        defaults,
+        Permission.fromConfig({
+          '*': 'deny',
+          grep: 'allow',
+          glob: 'allow',
+          list: 'allow',
+          bash: 'allow',
+          webfetch: 'allow',
+          websearch: 'allow',
+          read: 'allow',
+          external_directory: { '*': 'ask' },
+        }),
+        user
+      ),
+      description:
+        'Fast agent specialized for exploring codebases. Use this when you need to quickly find files by patterns (eg. "src/components/**/*.tsx"), search code for keywords (eg. "API endpoints"), or answer questions about the codebase (eg. "how do API endpoints work?"). When calling this agent, specify the desired thoroughness level: "quick" for basic searches, "medium" for moderate exploration, or "very thorough" for comprehensive analysis across multiple locations and naming conventions.',
+      prompt: opts.promptExplore || '',
+      options: {},
+      mode: 'subagent',
+      native: true,
+    },
+    /* opencode custom-agent deseni (mode: 'all'): Beast Sandbox — GitHub'dan
+       indirilmiş açık kaynak repo klasöründe koşan build ajanı. Repo disiplini
+       + panel_run (ÇALIŞTIR paneli) izni buradan gelir */
+    sandbox: {
+      name: 'sandbox',
+      description: 'Beast Sandbox agent. Works inside an open-source repo cloned from GitHub; follows the repo owner conventions.',
+      options: {},
+      permission: Permission.merge(
+        defaults,
+        Permission.fromConfig({
+          question: 'allow',
+          panel_run: { '*': 'allow' },
+        }),
+        user
+      ),
+      prompt: [
+        'BEAST SANDBOX MODUNDASIN: GitHub\u2019dan indirilmi\u015f A\u00c7IK KAYNAK bir repo klas\u00f6r\u00fcndesin (Beast-Sandbox). Bu kodun sahibi de\u011filsin \u2014 hazir bir di\u015f proje; repo sahibinin konvansiyonlarina uy, gereksiz yeniden bi\u00e7imlendirme yapma.',
+        '\u0130\u015fe README + paket bildirim dosyalar\u0131yla ba\u015fla (list/glob); ba\u011f\u0131ml\u0131l\u0131klar kurulu de\u011filse \u00f6nce kurulum komutunu \u00e7al\u0131\u015ft\u0131r (npm install vb.).',
+        'UZUN S\u00dcREL\u0130 sunucu/s\u00fcre\u00e7 (npm start, npm run dev, python app.py vb.) bash ile ASLA ba\u015flatma \u2014 tur kilitlenir; kullan\u0131c\u0131 \u00e7al\u0131\u015ft\u0131rmak isterse panel_run arac\u0131yla \u00c7ALI\u015eTIR paneline b\u0131rak (\u00e7\u0131kt\u0131 orada canl\u0131 akar) ve adresi kullan\u0131c\u0131ya bildir. panel_run yaln\u0131z B\u0130R s\u00fcre\u00e7 \u00e7al\u0131\u015ft\u0131r\u0131r.',
+      ].join('\n'),
+      mode: 'all',
+      native: false,
+    },
+  };
+}
+
+/* opencode Agent.get(name) — bilinmeyen isim null döner (çağıran hata basar) */
+function get(name, opts = {}) {
+  const agents = build(opts);
+  return agents[name] || null;
+}
+
+/* opencode Agent.list() — alfabetik, build önce */
+function list(opts = {}) {
+  const agents = Object.values(build(opts));
+  return agents.sort((a, b) => (a.name === 'build' ? -1 : b.name === 'build' ? 1 : a.name.localeCompare(b.name)));
+}
+
+/* opencode Agent.defaultInfo() — görünür primary ajan (build) */
+function defaultInfo(opts = {}) {
+  const agents = Object.values(build(opts));
+  return agents.find((a) => a.mode !== 'subagent' && a.hidden !== true) || agents[0];
+}
+
+module.exports = { get, list, defaultInfo, build, defaultRuleset, planRules };

package/src/agent/opencode/askperm.js

@@ -0,0 +1,135 @@
+'use strict';
+
+/* ---------- opencode permission Service portu (index.ts:67-167) ----------
+   Ask akışı: her pattern için kural değerlendirilir (ruleset + approved) →
+     deny  → PermissionDeniedError (asla sorulmaz, anında hata)
+     allow → geç
+     ask   → kullanıcıya sorulur
+   Sorulacaklar: 'permission.asked' eventi yayınlanır (UI/WA dinler) ve
+   promise bekletilir. Cevap (reply):
+     'once'   → yalnız bu istek serbest
+     'always' → pattern'ler oturum boyu approved listesine kural olarak eklenir;
+                aynı oturumdaki diğer pending'lerden artık allow olanlar da serbest bırakılır
+     'reject' → RejectedError (feedback'siz) veya CorrectedError (feedback'li);
+                aynı oturumdaki DİĞER pending istekler de reddedilir (opencode birebir)
+
+   Hata nesneleri araç çıktısına JSON hata olarak akıtılır; opencode
+   core/v1/permission.ts mesajları kullanılır. */
+
+const Permission = require('./permission');
+
+let seq = 0;
+function newId() {
+  return 'prm_' + Date.now().toString(36) + (++seq).toString(36);
+}
+
+class AskService {
+  constructor(emitFn) {
+    this.emit = typeof emitFn === 'function' ? emitFn : () => {};
+    this.pending = new Map(); // id -> { info, resolve, reject }
+    this.approved = []; // oturumlar arası paylaşılan kural listesi (engine'e aşılanır)
+  }
+
+  /* opencode Permission.ask — throws: { kind:'denied'|'rejected'|'corrected', feedback? } */
+  ask({ sessionId, ruleset, permission, patterns, metadata, always, tool }) {
+    const pats = Array.isArray(patterns) && patterns.length ? patterns : ['*'];
+    let needsAsk = false;
+    for (const pattern of pats) {
+      const rule = Permission.evaluate(permission, pattern, ruleset || [], this.approved);
+      if (rule.action === 'deny') {
+        throw { kind: 'denied', permission, pattern };
+      }
+      if (rule.action === 'allow') continue;
+      needsAsk = true;
+    }
+    if (!needsAsk) return Promise.resolve();
+
+    const id = newId();
+    const info = {
+      id,
+      sessionID: String(sessionId || ''),
+      permission,
+      patterns: pats,
+      metadata: metadata || {},
+      always: Array.isArray(always) ? always : [],
+      tool: tool || null,
+    };
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, { info, resolve, reject });
+      try {
+        this.emit({ type: 'permission.asked', sessionId: info.sessionID, request: info });
+      } catch {}
+      /* güvenlik: emit kanalı koptuysa pending asılı kalmasın */
+      setTimeout(() => {
+        if (this.pending.has(id)) {
+          this.pending.delete(id);
+          reject({ kind: 'rejected' });
+        }
+      }, 5 * 60 * 1000);
+    });
+  }
+
+  /* opencode Permission.reply — UI/WA tarafından çağrılır */
+  reply(requestId, action, message) {
+    const id = String(requestId || '');
+    const existing = this.pending.get(id);
+    if (!existing) return { ok: false, error: 'bekleyen izin isteği yok' };
+    this.pending.delete(id);
+    const { info } = existing;
+    try {
+      this.emit({ type: 'permission.replied', sessionId: info.sessionID, requestId: id, reply: action });
+    } catch {}
+
+    if (action === 'reject') {
+      const err = message ? { kind: 'corrected', feedback: String(message) } : { kind: 'rejected' };
+      existing.reject(err);
+      /* aynı oturumdaki diğer pending'ler de reddedilir (opencode birebir) */
+      for (const [pid, item] of [...this.pending.entries()]) {
+        if (item.info.sessionID !== info.sessionID) continue;
+        this.pending.delete(pid);
+        try {
+          this.emit({ type: 'permission.replied', sessionId: item.info.sessionID, requestId: pid, reply: 'reject' });
+        } catch {}
+        item.reject({ kind: 'rejected' });
+      }
+      return { ok: true };
+    }
+
+    existing.resolve();
+    if (action === 'once') return { ok: true };
+
+    /* 'always' — pattern bazlı kural yazılır (opencode birebir) */
+    for (const pattern of info.always) {
+      this.approved.push({ permission: info.permission, pattern, action: 'allow' });
+    }
+    for (const [pid, item] of [...this.pending.entries()]) {
+      if (item.info.sessionID !== info.sessionID) continue;
+      const ok = item.info.patterns.every(
+        (pattern) => Permission.evaluate(item.info.permission, pattern, this.approved).action === 'allow'
+      );
+      if (!ok) continue;
+      this.pending.delete(pid);
+      try {
+        this.emit({ type: 'permission.replied', sessionId: item.info.sessionID, requestId: pid, reply: 'always' });
+      } catch {}
+      item.resolve();
+    }
+    return { ok: true };
+  }
+
+  /* bekleyen istekler (UI listesi için) */
+  list() {
+    return [...this.pending.values()].map((x) => x.info);
+  }
+
+  /* hata nesnesini araç çıktısı metnine çevirir (opencode mesajları) */
+  static errorText(err) {
+    if (!err) return 'Permission denied';
+    if (err.kind === 'denied') return 'Permission denied';
+    if (err.kind === 'corrected')
+      return 'The user rejected the permission request and gave feedback: ' + String(err.feedback || '');
+    return Permission.MESSAGES.rejected;
+  }
+}
+
+module.exports = { AskService };

package/src/agent/opencode/index.js

@@ -0,0 +1,51 @@
+'use strict';
+
+/* ---------- opencode mantığı — Beast Code portu (birleşim) ----------
+   opencode-dev/packages/opencode/src çekirdek mimarisinin CommonJS portu:
+
+     agents.js        → agent/agent.ts      (build/plan/general/explore + permission)
+     permission.js    → permission/index.ts  (ruleset, evaluate findLast, fromConfig)
+     askperm.js       → permission Service   (ask/reply: once|always|reject)
+     systemprompt.js  → session/system.ts + reminders.ts
+     toolmap.js       → tool/registry.ts builtin seti (read/edit/write/bash/...)
+     prompts/         → session/prompt/*.txt + tool/*.txt (opencode-dev'den birebir)
+
+   Kullanım (engine, bcCode oturumlarında):
+     opencode.agents.get(name, {worktree})          → Agent.Info
+     opencode.system.provider(modelId)             → model-bazlı ana prompt
+     opencode.toolmap.definitions()                → modele sunulacak opencode araç seti
+     opencode.toolmap.execMap(name, args)          → Beast aracına çevirim
+     opencode.Permission                           → kural motoru
+     opencode.AskService                           → izin isteme/yanıtlama servisi */
+
+const fs = require('fs');
+const path = require('path');
+
+const PROMPTS_DIR = path.join(__dirname, 'prompts');
+function loadPrompt(name) {
+  try {
+    return fs.readFileSync(path.join(PROMPTS_DIR, name), 'utf8').replace(/\s+$/, '');
+  } catch {
+    return '';
+  }
+}
+
+const MAX_STEPS_PROMPT = loadPrompt('max-steps.txt');
+const PROMPT_EXPLORE = loadPrompt('explore.txt');
+
+const agents = require('./agents');
+const Permission = require('./permission');
+const { AskService } = require('./askperm');
+const systemprompt = require('./systemprompt');
+const toolmap = require('./toolmap');
+
+module.exports = {
+  agents,
+  Permission,
+  AskService,
+  systemprompt,
+  toolmap,
+  MAX_STEPS_PROMPT,
+  PROMPT_EXPLORE,
+  loadPrompt,
+};