beast-agent 2.70.0 → 2.72.0

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "beast-agent",
     "productName": "Beast Agent",
-    "version": "2.70.0",
+    "version": "2.72.0",
     "description": "Ultra-fast local agent shell for Windows.",
     "author": "algokodcom (AlgoKod)",
     "license": "MIT",

package/src/agent/customtools.js

@@ -15,6 +15,11 @@ const path = require('path');
 const { spawn } = require('child_process');
 const { beastRoot } = require('./memory');
 
+/* Varsayılan 90 sn; tool.json'daki "timeoutMs" ile araç başına uzatılabilir
+   (üst sınır 15 dk) — uzun işler için (ör. fastbrowse tarayıcı ajanı). */
+const TOOL_TIMEOUT_MS = 90 * 1000;
+const TOOL_TIMEOUT_MAX_MS = 15 * 60 * 1000;
+
 let notify = () => {};
 function setNotify(fn) {
   notify = typeof fn === 'function' ? fn : () => {};
@@ -80,6 +85,7 @@ function readTool(d) {
           : { type: 'object', properties: {} },
       script: runJs,
       code: fs.readFileSync(runJs, 'utf8').slice(0, 20000),
+      timeoutMs: Math.max(5000, Math.min(TOOL_TIMEOUT_MAX_MS, Number(json.timeoutMs) || TOOL_TIMEOUT_MS)),
       updatedAt: json.updatedAt || null,
     };
   } catch {
@@ -122,8 +128,6 @@ function names() {
   return cache.map((t) => 'tool__' + t.id);
 }
 
-const TOOL_TIMEOUT_MS = 90 * 1000;
-
 /* Tool'u çocuk node prosesinde koşturur — uygulama asla çökmez */
 function call(name, args, sid) {
   return new Promise((resolve) => {
@@ -157,8 +161,8 @@ function call(name, args, sid) {
     };
     let killer = setTimeout(() => {
       try { child && child.kill(); } catch {}
-      finish({ ok: false, error: 'tool zaman aşımı (' + Math.round(TOOL_TIMEOUT_MS / 1000) + ' sn)' });
-    }, TOOL_TIMEOUT_MS);
+      finish({ ok: false, error: 'tool zaman aşımı (' + Math.round(t.timeoutMs / 1000) + ' sn)' });
+    }, t.timeoutMs);
     try {
       /* Araç ortamı: BEAST_* değişkenleri — tool'lar köprü/python yolunu ve
          argümanları buradan güvenle çözebilir (stdin yanı sıra yedek kanal).

package/src/agent/defaulttools/fastbrowse_task/fastbrowse_bridge.py

@@ -0,0 +1,385 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Beast Agent <-> fastbrowse köprüsü (JEV seçer, LLM okur, kod uygular).
+
+stdin : JSON argümanlar (tool__fastbrowse_task ile aynı şema)
+stdout: TEK JSON sonuç
+
+Kimlikler args'tan GEÇMEZ: TypeSafe anahtarı ve OpenAI-uyumlu sağlayıcı
+(DeepSeek / z.ai ...) %APPDATA%\\beast\\settings.json'dan okunur — model hiç
+görmez. LLM istemcisi fastbrowse'un OpenAICompatibleLLM'i; response_format
+json_schema'yı desteklemeyen sağlayıcılar için istek gövdesi httpx transport
+katmanında json_object'e indirilir ve şema sistem mesajına eklenir.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import re
+import sys
+from pathlib import Path
+
+
+def _emit(obj: dict) -> None:
+    try:
+        sys.stdout.reconfigure(encoding="utf-8")
+    except Exception:
+        pass
+    sys.stdout.write(json.dumps(obj, ensure_ascii=False) + "\n")
+    sys.stdout.flush()
+
+
+def _read_args() -> dict:
+    try:
+        raw = sys.stdin.read()
+    except Exception:
+        raw = ""
+    try:
+        obj = json.loads(raw or "{}")
+        return obj if isinstance(obj, dict) else {}
+    except Exception:
+        return {}
+
+
+def _beast_root() -> Path:
+    env = os.environ.get("BEAST_ROOT")
+    if env:
+        return Path(env)
+    return Path(os.environ.get("APPDATA") or ".") / "beast"
+
+
+def _load_settings() -> dict:
+    try:
+        return json.loads((_beast_root() / "settings.json").read_text(encoding="utf-8"))
+    except Exception:
+        return {}
+
+
+def _pick_provider(settings: dict, want: str, model: str):
+    """Aktif modelin sağlayıcısı (modelOverride: custom:<id>::<model>) ya da
+    istenen ad/kimlik; yoksa ilk özel sağlayıcı. Anahtar yalnız burada çözülür."""
+    provs = settings.get("customProviders")
+    if not isinstance(provs, list):
+        provs = []
+    want = str(want or "").strip().lower()
+    mo = str(settings.get("modelOverride") or "")
+    m = re.match(r"custom:([^:]+)::(.+)$", mo)
+    mo_id = m.group(1) if m else ""
+    mo_model = m.group(2) if m else ""
+    chosen = None
+    if want:
+        for p in provs:
+            if not isinstance(p, dict):
+                continue
+            if want in (str(p.get("id") or "").lower(), str(p.get("name") or "").lower()):
+                chosen = p
+                break
+    if chosen is None and mo_id:
+        for p in provs:
+            if isinstance(p, dict) and str(p.get("id") or "") == mo_id:
+                chosen = p
+                break
+    if chosen is None and provs and isinstance(provs[0], dict):
+        chosen = provs[0]
+    if not chosen:
+        return None
+    base = str(chosen.get("baseUrl") or "").strip()
+    key = str(chosen.get("key") or "").strip()
+    mdl = str(model or "").strip()
+    if not mdl:
+        if mo_model and str(chosen.get("id") or "") == mo_id:
+            mdl = mo_model
+        else:
+            models = chosen.get("models")
+            if isinstance(models, list) and models:
+                mdl = str(models[0])
+    if not (base and key and mdl):
+        return None
+    return {
+        "name": str(chosen.get("name") or chosen.get("id") or "?"),
+        "baseUrl": base,
+        "apiKey": key,
+        "model": mdl,
+    }
+
+
+def _make_http():
+    """httpx istemcisi: görsel soyma + json_schema indirgemesi (taşıma katmanı)."""
+    import httpx
+
+    class _SchemaDowngrade(httpx.AsyncBaseTransport):
+        def __init__(self, inner):
+            self._inner = inner
+
+        async def aclose(self):
+            await self._inner.aclose()
+
+        async def handle_async_request(self, request):
+            payload = None
+            is_llm = False
+            try:
+                if request.content and b"messages" in request.content:
+                    body = json.loads(request.content.decode("utf-8"))
+                    changed = False
+                    msgs = body.get("messages")
+                    if isinstance(msgs, list):
+                        # 1) GÖRSEL SOYMA: sağlayıcı (GLM/DeepSeek) görsel kabul etmiyorsa
+                        #    image_url parçaları düşer, metin korunur ve kısa bir not eklenir.
+                        for m in msgs:
+                            if not isinstance(m, dict):
+                                continue
+                            c = m.get("content")
+                            if isinstance(c, list):
+                                texts = [
+                                    str(p.get("text") or "")
+                                    for p in c
+                                    if isinstance(p, dict) and p.get("type") == "text"
+                                ]
+                                had_image = any(
+                                    isinstance(p, dict) and p.get("type") == "image_url" for p in c
+                                )
+                                joined = "\n".join(t for t in texts if t)
+                                if had_image:
+                                    joined += "\n[ekran görüntüsü bu sağlayıcıya gönderilemedi — metinle devam et]"
+                                m["content"] = joined
+                                changed = True
+                        # 2) JSON ŞEMA İNDİRGEMESİ: json_schema → json_object + şema sistem mesajı
+                        rf = body.get("response_format")
+                        if isinstance(rf, dict) and rf.get("type") == "json_schema":
+                            schema = (rf.get("json_schema") or {}).get("schema")
+                            body["response_format"] = {"type": "json_object"}
+                            msgs.insert(
+                                0,
+                                {
+                                    "role": "system",
+                                    "content": "Yalnızca tek bir JSON nesnesi döndür; JSON dışında hiçbir metin yazma. Şu JSON Schema'ya uy: "
+                                    + json.dumps(schema, ensure_ascii=False),
+                                },
+                            )
+                            changed = True
+                        if changed:
+                            body["messages"] = msgs
+                            payload = json.dumps(body, ensure_ascii=False).encode("utf-8")
+                        else:
+                            payload = request.content
+                        is_llm = True
+            except Exception:
+                pass
+            req = request
+            if payload is not None:
+                headers = [(k, v) for (k, v) in request.headers.raw if k.lower() != b"content-length"]
+                req = httpx.Request(
+                    request.method,
+                    request.url,
+                    headers=headers,
+                    content=payload,
+                    extensions=request.extensions,
+                )
+            # NOT: 429/5xx yeniden deneme fastbrowse'un post_with_retry katmanında zaten var
+            # (Retry-After'a saygılı) — burada TEKRAR denenmez, yoksa girişimler çoğalır.
+            return await self._inner.handle_async_request(req)
+
+    return httpx.AsyncClient(timeout=60, transport=_SchemaDowngrade(httpx.AsyncHTTPTransport()))
+
+
+async def _resolve_cdp(client, args: dict) -> str:
+    """Beast dahili Chromium CDP: DevToolsActivePort dosyası → /json/version → ws URL."""
+    url = str(args.get("cdp_url") or "").strip()
+    if url.startswith(("ws://", "wss://")):
+        return url
+    port = 0
+    try:
+        port = int(str(args.get("cdp_port") or "0") or 0)
+    except Exception:
+        port = 0
+    if not port:
+        appdata = Path(os.environ.get("APPDATA") or ".")
+        for name in ("Beast Agent", "beast-agent", "beast"):
+            f = appdata / name / "DevToolsActivePort"
+            try:
+                if f.exists():
+                    port = int(f.read_text(encoding="utf-8").splitlines()[0].strip())
+                    break
+            except Exception:
+                continue
+    if not port:
+        raise RuntimeError("DevToolsActivePort bulunamadı (Beast açık mı?)")
+    r = await client.get("http://127.0.0.1:%d/json/version" % port)
+    r.raise_for_status()
+    ws = (r.json() or {}).get("webSocketDebuggerUrl")
+    if not ws:
+        raise RuntimeError("CDP webSocketDebuggerUrl yok (port %d)" % port)
+    return str(ws)
+
+
+_HINTS = {
+    "needs_confirmation": "Geri alınamaz aksiyonda durdu (gönder/öde/sil). Kullanıcıdan onay al; uygunsa authorize:true ile tekrar çağır.",
+    "needs_login": "Giriş duvarı var; kayıtlı kimlik çözülemedi. Kullanıcıdan giriş bilgisi/profil iste.",
+    "needs_input": "Form alanı için değer verilmedi (model uydurmaz). Kullanıcıdan değeri al.",
+    "blocked": "Bot kontrolü (CAPTCHA) geçilemedi; kullanıcının çözmesi gerekebilir.",
+    "stuck": "İlerleme olmadan takıldı; görevi/dilimi netleştirip tekrar dene.",
+    "budget_exceeded": "Adım/süre limiti doldu; max_steps/max_seconds artır ya da görevi böl.",
+    "observation_limit": "Sayfa Jev'in girdi limitini aştı; daha dar bir görev/hedef ver.",
+    "unverified": "Bitti sanıyor ama tüm iddialar kanıtlanamadı — answer'a temkinli yaklaş, sonucu doğrula.",
+    "error": "Çalıştırma hatası; error alanına bak.",
+}
+
+
+def _result_dict(res, provider: dict, browser: str) -> dict:
+    try:
+        cost = {"known_dollars": round(float(res.cost.known_dollars), 4), "unknown": bool(res.cost.has_unknown)}
+    except Exception:
+        cost = None
+    steps = []
+    try:
+        for s in list(res.steps)[-30:]:
+            steps.append(
+                {
+                    "i": s.index,
+                    "op": getattr(s.operation, "value", str(s.operation)),
+                    "karar": getattr(s.decided_by, "value", ""),
+                    "sonuc": getattr(s.outcome, "value", ""),
+                    "hedef": s.target,
+                    "url": s.url,
+                }
+            )
+    except Exception:
+        pass
+    evidence = []
+    try:
+        for e in list(res.evidence)[:10]:
+            quote = " ".join(str(e.quote or "").split())
+            evidence.append({"quote": quote[:400], "url": e.url})
+    except Exception:
+        pass
+    status = getattr(res.status, "value", str(res.status))
+    return {
+        "ok": status == "complete",
+        "status": status,
+        "answer": res.answer,
+        "final_url": res.final_url,
+        "evidence": evidence,
+        "steps": steps,
+        "cost": cost,
+        "browser": browser,
+        "provider": provider["name"] + ":" + provider["model"],
+        "error": res.error,
+        "hint": _HINTS.get(status, ""),
+    }
+
+
+async def _run(args: dict) -> dict:
+    from fastbrowse import run_task
+    from fastbrowse.clients.openai_compatible import OpenAICompatibleLLM
+    from fastbrowse.clients.typesafe import TYPESAFE_URL, TypeSafeJevClient
+    from fastbrowse.jev import JEV_MODEL
+    from fastbrowse.models import Authorization, Limits, LLMPurpose, LocalChrome
+
+    settings = _load_settings()
+    ts = settings.get("typesafe") if isinstance(settings.get("typesafe"), dict) else {}
+    ts_key = str(ts.get("apiKey") or "").strip()
+    if not ts_key:
+        return {
+            "ok": False,
+            "status": "error",
+            "error": "TypeSafe (Jev) API anahtarı yok",
+            "hint": "Ayarlar → TypeSafe sekmesinden anahtarı gir.",
+        }
+    if ts.get("enabled") is False:
+        return {
+            "ok": False,
+            "status": "error",
+            "error": "TypeSafe ayarı KAPALI",
+            "hint": "Ayarlar → TypeSafe → anahtarı aç.",
+        }
+    provider = _pick_provider(settings, str(args.get("provider") or ""), str(args.get("model") or ""))
+    if not provider:
+        return {
+            "ok": False,
+            "status": "error",
+            "error": "OpenAI-uyumlu LLM sağlayıcısı bulunamadı (customProviders boş ya da anahtarsız)",
+            "hint": "Ayarlar → Provider'dan özel sağlayıcı ekle (ör. DeepSeek / z.ai) ve model seç.",
+        }
+
+    def _clamp(v, lo, hi, default):
+        try:
+            return max(lo, min(hi, type(default)(v)))
+        except Exception:
+            return default
+
+    max_steps = _clamp(args.get("max_steps"), 5, 80, 40)
+    max_seconds = _clamp(args.get("max_seconds"), 30.0, 600.0, 180.0)
+    limits = Limits(max_steps=max_steps, max_seconds=max_seconds, max_llm_calls=50)
+    authorization = Authorization(irreversible_actions=bool(args.get("authorize")))
+
+    def _local_chrome():
+        binary = str(args.get("chrome") or os.environ.get("FASTBROWSE_CHROME") or "").strip()
+        return LocalChrome(binary=binary or None, headed=bool(args.get("headed")))
+
+    http = _make_http()
+    try:
+        jev = TypeSafeJevClient(
+            ts_key,
+            http=http,
+            base_url=TYPESAFE_URL,
+            model=str(ts.get("model") or "").strip() or JEV_MODEL,
+        )
+        llm = OpenAICompatibleLLM(
+            provider["apiKey"],
+            http=http,
+            base_url=provider["baseUrl"],
+            models={purpose: provider["model"] for purpose in LLMPurpose},
+            reasoning_effort=None,  # sağlayıcıya özel 'reasoning' alanı gönderilmez
+        )
+        kwargs = {"jev": jev, "llm": llm, "limits": limits, "authorization": authorization, "http": http}
+        mode = str(args.get("mode") or "cdp").strip().lower()
+        if mode == "chrome":
+            kwargs["chrome"] = _local_chrome()
+            browser = "chrome"
+        else:
+            try:
+                kwargs["cdp_url"] = await _resolve_cdp(http, args)
+                browser = "cdp (Beast dahili)"
+            except Exception as e:
+                kwargs["chrome"] = _local_chrome()
+                browser = "chrome (cdp yok: %s)" % str(e)[:80]
+        res = await run_task(
+            str(args.get("task") or "").strip(),
+            start=(str(args.get("start") or "").strip() or None),
+            **kwargs,
+        )
+    finally:
+        try:
+            await http.aclose()
+        except Exception:
+            pass
+    return _result_dict(res, provider, browser)
+
+
+def main() -> None:
+    args = _read_args()
+    if not str(args.get("task") or "").strip():
+        _emit({"ok": False, "status": "error", "error": "task gerekli (doğal dil hedef)"})
+        return
+    try:
+        result = asyncio.run(_run(args))
+    except ModuleNotFoundError as e:
+        _emit(
+            {
+                "ok": False,
+                "status": "error",
+                "error": "fastbrowse yüklenemedi: " + str(e),
+                "hint": "uv kurulu ve internet erişimi var mı? (uv run fastbrowse==0.4.2 ortamı kurar)",
+            }
+        )
+        return
+    except Exception as e:
+        _emit({"ok": False, "status": "error", "error": type(e).__name__ + ": " + str(e)[:400]})
+        return
+    _emit(result)
+
+
+if __name__ == "__main__":
+    main()

package/src/agent/defaulttools/fastbrowse_task/run.js

@@ -0,0 +1,119 @@
+'use strict';
+// FASTBROWSE KÖPRÜSÜ — stdin: JSON args · stdout: JSON sonuç
+// fastbrowse (Python 3.13) uv ile izole ortamda çalışır; anahtar/kimlik bilgileri
+// args'tan GEÇMEZ — köprü %APPDATA%\beast\settings.json'dan okur (model hiç görmez).
+const { spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+function readArgs() {
+  try { return JSON.parse(fs.readFileSync(0, 'utf8') || '{}') || {}; } catch { return {}; }
+}
+
+/* uv bul: PATH'te yoksa uv'un resmi kurulum yerleri denenir */
+function findUv() {
+  const cands = [];
+  if (process.env.UV) cands.push(String(process.env.UV));
+  if (process.env.USERPROFILE) cands.push(path.join(process.env.USERPROFILE, '.local', 'bin', 'uv.exe'));
+  if (process.env.LOCALAPPDATA) cands.push(path.join(process.env.LOCALAPPDATA, 'Microsoft', 'WinGet', 'Links', 'uv.exe'));
+  for (const c of cands) { try { if (c && fs.existsSync(c)) return c; } catch {} }
+  return 'uv';
+}
+
+/* Chrome bul (chrome modu yedeği; köprü FASTBROWSE_CHROME'u kullanır) */
+function findChrome() {
+  const cands = [];
+  if (process.env.LOCALAPPDATA) cands.push(path.join(process.env.LOCALAPPDATA, 'Google', 'Chrome', 'Application', 'chrome.exe'));
+  cands.push('C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe');
+  cands.push('C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe');
+  for (const c of cands) { try { if (c && fs.existsSync(c)) return c; } catch {} }
+  return '';
+}
+
+function emit(obj) {
+  process.stdout.write(JSON.stringify(obj) + '\n');
+}
+
+const args = readArgs();
+const uv = findUv();
+const bridge = path.join(__dirname, 'fastbrowse_bridge.py');
+if (!fs.existsSync(bridge)) {
+  emit({ ok: false, status: 'error', error: 'köprü dosyası yok: ' + bridge, hint: 'Araç klasörünü yeniden kur (uygulamayı yeniden başlat).' });
+  process.exit(0);
+}
+
+const env = { ...process.env, PYTHONUTF8: '1', PYTHONIOENCODING: 'utf-8' };
+if (!env.FASTBROWSE_CHROME) {
+  const chrome = findChrome();
+  if (chrome) env.FASTBROWSE_CHROME = chrome;
+}
+
+const UV_TIMEOUT_MS = 330000; /* customtools zaman aşımının (360 sn) altında kal */
+let child = null;
+let out = '';
+let err = '';
+let settled = false;
+const finish = (obj) => {
+  if (settled) return;
+  settled = true;
+  clearTimeout(killer);
+  try { child && child.kill(); } catch {}
+  emit(obj);
+};
+
+const killer = setTimeout(() => {
+  finish({ ok: false, status: 'error', error: 'fastbrowse zaman aşımı (uv/Chrome yanıt vermedi)', stderr: String(err || '').slice(-500) });
+}, UV_TIMEOUT_MS);
+
+try {
+  child = spawn(uv, ['run', '--python', '3.13', '--with', 'fastbrowse==0.4.2', 'python', bridge], {
+    cwd: __dirname,
+    env,
+    windowsHide: true,
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
+} catch (e) {
+  finish({
+    ok: false,
+    status: 'error',
+    error: 'uv başlatılamadı: ' + String((e && e.message) || e),
+    hint: 'uv kur: winget install astral-sh.uv  (ya da https://docs.astral.sh/uv/)',
+  });
+  process.exit(0);
+}
+
+child.stdout.on('data', (d) => { out += d.toString('utf8'); });
+child.stderr.on('data', (d) => { err += d.toString('utf8'); if (err.length > 20000) err = err.slice(-12000); });
+child.on('error', (e) => {
+  finish({
+    ok: false,
+    status: 'error',
+    error: 'uv çalıştırılamadı: ' + String((e && e.message) || e),
+    hint: 'uv kur: winget install astral-sh.uv  (ya da https://docs.astral.sh/uv/)',
+  });
+});
+child.on('close', (code) => {
+  /* uv/python kendi log'larını stderr'e yazar; stdout'tan SON geçerli JSON satırını al */
+  let result = null;
+  for (const line of String(out || '').split(/\r?\n/).map((s) => s.trim()).filter(Boolean)) {
+    try {
+      const o = JSON.parse(line);
+      if (o && typeof o === 'object' && typeof o.ok === 'boolean') result = o;
+    } catch {}
+  }
+  if (!result) {
+    result = {
+      ok: false,
+      status: 'error',
+      error: 'fastbrowse sonuç üretemedi (çıkış kodu ' + code + ')',
+      stderr: String(err || '').slice(-800),
+    };
+  }
+  if (!result.ok && !result.hint && code !== 0) result.hint = String(err || '').slice(-200) || 'çıkış kodu ' + code;
+  finish(result);
+});
+
+try {
+  child.stdin.write(JSON.stringify(args));
+  child.stdin.end();
+} catch {}

package/src/agent/defaulttools/fastbrowse_task/tool.json

@@ -0,0 +1,50 @@
+{
+  "name": "fastbrowse_task",
+  "description": "HIZLI TARAYICI AJANI (fastbrowse · Jev seçer, LLM okur, kod doğrular): doğal dilde TEK hedef ver; sayfayı element listesine indeksler, her adımı Jev (TypeSafe) seçer ve cevabı sayfadan BİREBİR ALINTILARLA döndürür. Çok adımlı işler (arama + form + filtre + tarih seçimi + sonuç okuma) için browser_click/browser_type zinciri yerine bunu tercih et. Varsayılan mode:'cdp' Beast'in DAHİLİ Chromium'una bağlanır (kendi sekmesini açar/kapatır, senin sekmelerine dokunmaz); mode:'chrome' kendi Chrome'unu açar. Geri alınamaz aksiyonlar (gönder/öde/sil) authorize:true verilmeden DURUR ve status:'needs_confirmation' döner. status:'complete' DEĞİLSE başarıyı iddia etme: dönen answer + evidence alıntılarını kullanıcıya aktar; needs_login/needs_input/blocked durumlarında kullanıcıdan bilgi iste. Aynı iş için elle browser_click/browser_type zinciri kurma — tek çağrıda hedefi ver.",
+  "parameters": {
+    "type": "object",
+    "properties": {
+      "task": {
+        "type": "string",
+        "description": "Doğal dil hedef: \"Hacker News'teki en üst haberin başlığını bul\" gibi. Tek net hedef ver; gereksiz 've' ile işleri birleştirme."
+      },
+      "start": {
+        "type": "string",
+        "description": "Başlangıç URL'i (ör. https://news.ycombinator.com/). Boşsa ilk adres görevden çıkarılır."
+      },
+      "mode": {
+        "type": "string",
+        "enum": ["cdp", "chrome"],
+        "description": "cdp: Beast dahili Chromium (varsayılan, giriş yapılmış oturumu kullanır); chrome: kendi Chrome'unu başlatır (Beast kapalıyken/yedek)."
+      },
+      "provider": {
+        "type": "string",
+        "description": "LLM sağlayıcı adı/kimliği (Ayarlar → Provider'daki özel sağlayıcı; boşsa aktif modelin sağlayıcısı)."
+      },
+      "model": {
+        "type": "string",
+        "description": "LLM modeli (boşsa sağlayıcının/aktif modelin varsayılanı)."
+      },
+      "authorize": {
+        "type": "boolean",
+        "description": "true: geri alınamaz aksiyonlara (gönder/öde/sil/onayla) izin ver. Varsayılan false — güvenli."
+      },
+      "headed": {
+        "type": "boolean",
+        "description": "chrome modunda pencereyi göster (varsayılan false = headless)."
+      },
+      "max_steps": {
+        "type": "number",
+        "description": "Adım tavanı (varsayılan 40, en çok 80)."
+      },
+      "max_seconds": {
+        "type": "number",
+        "description": "Süre tavanı saniye (varsayılan 180, en çok 600)."
+      }
+    },
+    "required": ["task"]
+  },
+  "timeoutMs": 360000,
+  "defaultsVersion": 1,
+  "updatedAt": "2026-09-21T10:00:00.000Z"
+}

package/src/agent/financetools.js

@@ -920,34 +920,53 @@ const handlers = {
     const info = await symInfoRow(symbol);
     if (!info) return { ok: false, error: 'sembol bulunamadı: ' + symbol + ' (MT5 Market Watch?)' };
     const range = lotRange(cfg, symbol);
-    const norm = finrisk.normalizeVolume(info, args.volume, range.maxLot, range.minLot);
-    if (norm.error) return { ok: false, error: norm.error };
-    const vol = norm.volume;
     const ptype = t.type;
     const pside = t.side;
-    if (!(Number(args.price) > 0)) {
+    const entryPrice = Number(args.price) || 0;
+    if (!(entryPrice > 0)) {
       return { ok: false, error: 'price gerekli — limit/stop bekleyen emirleri için tetik fiyatı ver (market tipleri anlıktır, price istemez)' };
     }
+    /* LOT: riskPct verilirse BEKLEYEN EMİR fiyatı + SL mesafesinden hesaplanır
+       (piyasa emriyle aynı risk hattı); volume verilmişse normalize edilir. */
+    const explicitRisk = Number(args.riskPct) > 0 ? Number(args.riskPct) : 0;
+    let vol = 0;
+    let riskInfo = null;
+    if (explicitRisk > 0 || (!(Number(args.volume) > 0) && Number(cfg.riskPerTradePct) > 0)) {
+      const slRef = Number(args.sl) || 0;
+      if (!(slRef > 0)) return { ok: false, error: '%risk ile lot için sl zorunlu — sl ver ya da volume kullan' };
+      const riskPct = explicitRisk > 0 ? explicitRisk : Number(cfg.riskPerTradePct);
+      const acct = await bcall('account', {}, 8000);
+      const balance = Number(acct && acct.account && acct.account.balance) || 0;
+      const riskAmount = (balance * riskPct) / 100;
+      const rr = finrisk.calcRiskLot(info, entryPrice, slRef, riskAmount, range.maxLot, range.minLot);
+      if (rr.error) return { ok: false, error: rr.error };
+      vol = rr.volume;
+      riskInfo = { riskPct, riskAmount: Math.round(riskAmount * 100) / 100, lossPerLot: rr.lossPerLot, raised: !!rr.raised };
+    } else {
+      const norm = finrisk.normalizeVolume(info, args.volume, range.maxLot, range.minLot);
+      if (norm.error) return { ok: false, error: norm.error };
+      vol = norm.volume;
+    }
     /* KODLA DİSİPLİN: bekleyen emir de işlem sayılır */
     let discErr = null;
     try { discErr = discipline(pside, symbol, []); } catch {}
     if (discErr) return { ok: false, error: discErr };
     /* SHADOW MOD: bekleyen emir de GÖNDERİLMEZ — tez günlüğe düşer */
     if (cfg.shadowMode) {
-      noteTrade('shadow', { symbol, type: ptype, side: pside, volume: vol, price: Number(args.price) || 0, sl: Number(args.sl) || 0, tp: Number(args.tp) || 0, timeframe, reason: String(args.reason || '').slice(0, 500) }, ctx);
-      return { ok: true, shadow: true, note: 'SHADOW MOD: bekleyen emir GÖNDERİLMEDİ, karar günlüğe yazıldı.' };
+      noteTrade('shadow', { symbol, type: ptype, side: pside, volume: vol, price: entryPrice, sl: Number(args.sl) || 0, tp: Number(args.tp) || 0, timeframe, reason: String(args.reason || '').slice(0, 500), risk: riskInfo }, ctx);
+      return { ok: true, shadow: true, planned: { symbol, type: ptype, volume: vol, price: entryPrice, sl: Number(args.sl) || 0, tp: Number(args.tp) || 0 }, risk: riskInfo, note: 'SHADOW MOD: bekleyen emir GÖNDERİLMEDİ, karar günlüğe yazıldı.' };
     }
     const data = await bcall('pending', {
       symbol,
       type: ptype,
       volume: vol,
-      price: Number(args.price) || 0,
+      price: entryPrice,
       sl: Number(args.sl) || 0,
       tp: Number(args.tp) || 0,
       comment: orderComment,
     }, 20000);
-    noteTrade('pending', { symbol, type: ptype, volume: vol, timeframe, reason: String(args.reason || '').slice(0, 500) }, ctx);
-    return { ok: true, result: data && data.result, timeframe: timeframe || null };
+    noteTrade('pending', { symbol, type: ptype, volume: vol, price: entryPrice, sl: Number(args.sl) || 0, tp: Number(args.tp) || 0, timeframe, reason: String(args.reason || '').slice(0, 500), risk: riskInfo }, ctx);
+    return { ok: true, ordered: { symbol, type: ptype, volume: vol, price: entryPrice, sl: Number(args.sl) || 0, tp: Number(args.tp) || 0 }, risk: riskInfo, result: data && data.result, timeframe: timeframe || null };
   },
   async mt5_cancel(args, ctx) {
     if (!mt5.running) return notConnected();

package/src/main.js

@@ -12724,6 +12724,7 @@ function finTsDecRecord(rec) {
       rsi: Number.isFinite(Number(rec && rec.rsi)) ? Number(rec.rsi) : null,
       atrPct: Number.isFinite(Number(rec && rec.atrPct)) ? Number(rec.atrPct) : null,
       riskPct: Number(rec && rec.riskPct) || 0,
+      orderType: String((rec && rec.orderType) || 'market'),
       closedAt: 0, net: null, mfe: null, mae: null, reason: '',
     };
     d.decisions.push(item);
@@ -13589,8 +13590,10 @@ function finTeamWaitTick(sid) {
    yanıtları) YALNIZ TypeSafe System One'a gider; yanıtlar olasılık olarak
    döner, kararı KOD uygular. Yanıtlar AJAN DM ekip grubuna yazılır — tüm
    ajanlar birbirinin cevabını görür (son yanıtlar sonraki turların state'ine
-   de girer) ve emirler YALNIZ market buy/sell olarak açılır (bekleyen emir
-   YOK). LLM yalnız finance SOHBET yardımcısında serbesttir. */
+   de girer). Emir tipini de Jev seçer: market / buy-sell limit / buy-sell
+   stop; giriş seviyesi, SL/TP (sıkı-dengeli-geniş ATR profili), kısmi
+   kapatma, SL taşıma, fiyat alarmı ve araç isteği Jev kararıyla KOD tarafından
+   uygulanır. LLM yalnız finance SOHBET yardımcısında serbesttir. */
 const FIN_TS_MARGIN_P = 0.12;   /* birinci ile ikinci seçenek arası min fark */
 const FIN_TS_CONFIRM_P = 0.55;  /* noul teyit eşiği */
 const FIN_TS_EXIT_P = 0.62;     /* pozisyon kapatma eşiği */
@@ -13662,9 +13665,53 @@ function finTsFeedText(limit) {
   return feed.map((x) => `- ${x.who}: ${String(x.text || '').replace(/\s+/g, ' ').slice(0, 220)}`).join('\n');
 }
 
-/* ZAMAN DİLİMİ BOT KARARI: önce öğrenmede en iyi net getiren periyot (>=3
-   işlem), sonra ajanın seçimi, sonra rol varsayılanı */
+/* SAHİP TALİMATI: Trade Ajanı kartına yazılan strateji notu (Jev state'ine girer) */
+function finTsStrategyText() {
+  try {
+    return String(finCfg().strategy || '').slice(0, 1000);
+  } catch {
+    return '';
+  }
+}
+
+/* Talimattan ZAMAN DİLİMİ çıkar: "M15", "1m", "1 dk", "4 saat" → M15/M1/H4 */
+function finTsStrategyTf() {
+  const s = String(finTsStrategyText() || '');
+  const m = s.match(/\b(M1|M5|M15|M30|H1|H4|D1|W1|MN1)\b/i);
+  if (m) return m[1].toUpperCase();
+  const dk = s.match(/\b(\d{1,2})\s*(?:m|dk|dakika)\b/i);
+  if (dk) return finLearnNormTf('M' + Number(dk[1]));
+  const st = s.match(/\b(\d{1,2})\s*(?:h|saat)\b/i);
+  if (st) return finLearnNormTf('H' + Number(st[1]));
+  return '';
+}
+
+/* Talimat "zorunlu giriş" istiyor mu? ("her mumda işlem açmak zorundasın" gibi)
+   Olumsuz yazım ("zorunlu değil") modu AÇMAZ. */
+function finTsMandatoryEntry() {
+  const s = String(finTsStrategyText() || '').toLowerCase();
+  if (!s) return false;
+  if (/zorunlu değil|mecbur değil|zorunda değil/.test(s)) return false;
+  return /her mum|her barda?|her mumda|işlem açmak zorunda|her zaman işlem|sürekli işlem|durmadan işlem|zorunlu (?:olarak )?(?:işlem|giriş|al|sat)|mecbur/.test(s);
+}
+
+/* Ritim: talimatta M1 → işlem ajanı turları en hızlı 60 sn, M5 → 300 sn
+   (rol ajanları analiz ritmini korur; yalnız trader + sembol işçileri hızlanır) */
+function finTsStrategyPaceSec(agent) {
+  const base = finPaceSec();
+  if (!agent || agent.role) return base;
+  const tf = finTsStrategyTf();
+  if (tf === 'M1') return Math.max(30, Math.min(base, 60));
+  if (tf === 'M5') return Math.max(60, Math.min(base, 300));
+  return base;
+}
+
+/* ZAMAN DİLİMİ: önce SAHİBİN TALİMATI (işlem ajanları için), sonra öğrenmede
+   en iyi net getiren periyot (>=3 işlem), sonra ajanın seçimi, sonra rol
+   varsayılanı (rol ajanları kendi analiz periyodunu korur) */
 function finTsPickTf(agent, symbol) {
+  const owned = !(agent && agent.role) ? finTsStrategyTf() : '';
+  if (owned) return owned;
   try {
     const sym = String(symbol || '').toUpperCase();
     const e = finLearnLoad().symbols[sym];
@@ -13862,6 +13909,111 @@ async function finTsManageOpen(sidS, agent, sym, pos, mkt, ans, qi, lines) {
   }
 }
 
+/* JEV FİYAT ALARMI: Jev'in seçtiği seviyeye TEK SEFERLİK alarm kurar (kod).
+   Aynı sembol/yönde yakın bir alarm zaten varsa tekrar kurmaz (alarm seli yok).
+   Alarm tetiklenince finWakeAgents ilgili ajanı tur beklemeden uyandırır. */
+async function finTsSetAlarm(sidS, agent, sym, mkt, ans, i, lines) {
+  const c = finTsChoice(ans, 'alarm_' + i);
+  if (!c || String(c.choice) === 'yok') return;
+  if (!(c.p >= FIN_TS_CONFIRM_P && c.p - c.second >= FIN_TS_MARGIN_P)) return;
+  const row = (mkt && mkt.row) || {};
+  const ind = (mkt && mkt.ind) || {};
+  const ref = Number(row.bid) || Number(row.ask) || 0;
+  if (!(ref > 0)) return;
+  const atr = Number(ind.atr14) || 0;
+  const digits = Math.max(0, Math.min(8, Number(row.digits) || 2));
+  const rnd = (v) => Number(Number(v).toFixed(digits));
+  const range = ind.range20 || {};
+  const fallback = atr > 0 ? atr : ref * 0.003;
+  const choice = String(c.choice);
+  let direction = 'above';
+  let price = 0;
+  if (choice === 'ust_kirilim') { direction = 'above'; price = Number(range.high) || (ref + fallback); }
+  else if (choice === 'alt_kirilim') { direction = 'below'; price = Number(range.low) || (ref - fallback); }
+  else if (choice === 'yukari_atr') { direction = 'above'; price = ref + atr * 0.5; }
+  else if (choice === 'asagi_atr') { direction = 'below'; price = ref - atr * 0.5; }
+  else return;
+  /* seviye yanlış tarafta kalırsa (yeni tepe/dip) alarm anında tetiklenmesin */
+  const minAway = Math.max(atr * 0.2, ref * 0.0004);
+  if (direction === 'above' && price <= ref + minAway) price = ref + minAway;
+  if (direction === 'below' && price >= ref - minAway) price = ref - minAway;
+  price = rnd(price);
+  const tol = Math.max(atr * 0.15, price * 0.0005);
+  try {
+    const existing = (financeState.alerts || []).some((a) =>
+      a && String(a.symbol || '').toUpperCase() === sym &&
+      String(a.direction || '') === direction &&
+      Math.abs(Number(a.price) - price) <= tol
+    );
+    if (existing) {
+      lines.push(`- ${sym}: 🔔 alarm zaten var (${direction === 'above' ? '≥' : '≤'} ${price})`);
+      return;
+    }
+  } catch {}
+  let r = null;
+  try {
+    r = await financetools.handlers.mt5_alerts(
+      { action: 'set', symbol: sym, price, direction, mode: 'once', note: `TypeSafe seviye alarmı (p=${c.p.toFixed(2)})` },
+      { sessionId: sidS }
+    );
+  } catch (e) {
+    r = { ok: false, error: String((e && e.message) || e) };
+  }
+  if (r && r.ok) lines.push(`- ${sym}: 🔔 ALARM kuruldu ${direction === 'above' ? '≥' : '≤'} ${price} (tek seferlik)`);
+  else lines.push(`- ${sym}: alarm kurulamadı — ${(r && r.error) || 'hata'}`);
+}
+
+/* JEV ARAÇ İSTEĞİ: Jev'in seçtiği ihtiyaç kategorisini KOD somut isteğe çevirir
+   ve TOOL botuna ASENKRON yazar (engine._toolRequest). Ajan BEKLEMEZ; araç
+   hazır olunca rapor AJAN DM/sohbete düşer. Ajan başına saatte 1 istek. */
+async function finTsToolRequest(sidS, agent, ans, lines) {
+  const c = finTsChoice(ans, 'arac');
+  if (!c || String(c.choice) === 'yok') return;
+  if (!(c.p >= FIN_TS_CONFIRM_P && c.p - c.second >= FIN_TS_MARGIN_P)) return;
+  const now = Date.now();
+  if (agent.tsToolReqAt && now - agent.tsToolReqAt < 60 * 60 * 1000) {
+    lines.push(`- araç isteği (${c.choice}) atlandı — son istek 1 saatten yeni`);
+    return;
+  }
+  const syms = Array.isArray(agent.symbols) && agent.symbols.length ? agent.symbols.join(', ') : '(izleme listesi)';
+  const specs = {
+    haber: {
+      name: 'fin_haber_makro',
+      task:
+        'fin_haber_makro adında bir tool yaz: verilen sembol listesi için son haber başlıklarını ve bugünün yüksek etkili ekonomik takvim olaylarını toplayıp ' +
+        'JSON döndürsün: { ok, symbol, news:[{title, source, at, url}], calendar:[{time, currency, event, impact}] }. Girdi: {symbols:[...], hours:24}.',
+      context: `Kullanım: Beast Finance Jev ajanları makro/haber bağlamını karar state'ine koyacak. Örnek semboller: ${syms}. Haber için mevcut runner: src/agent/scripts/news.py (python) ve web_search/websearch.py köprüsü; takvim için investing/forexfactory benzeri ücretsiz kaynak. Çıktı sözleşmesi yukarıdaki JSON olmalı.`,
+    },
+    korelasyon: {
+      name: 'fin_korelasyon',
+      task:
+        'fin_korelasyon adında bir tool yaz: verilen semboller için son N mum kapanışından korelasyon matrisi + yönlü maruziyet özeti döndürsün: ' +
+        '{ ok, tf, matrix:{A:{B:r}}, exposure:{USD:net,...} }. Girdi: {symbols:[...], timeframe:"H1", count:300}.',
+      context: `Kullanım: aynı yönde birikmiş pozisyon riskini Jev kararlarında görmek için. MT5 köprüsü mt5_rates ile mum verisi çekilebilir (financetools.js desenine bak); saf matematik Node tarafında yapılabilir (getiri serisi → Pearson). Semboller: ${syms}.`,
+    },
+    rapor: {
+      name: 'fin_sembol_rapor',
+      task:
+        'fin_sembol_rapor adında bir tool yaz: bir sembolün son 30/90 gün kapanan işlemlerini öğrenme deposundan (finance/ogrenme.json) okuyup ' +
+        '{ ok, symbol, tf, trades, wins, net, avgR, bestTf, worstTf, topMistakes:[...] } özeti döndürsün. Girdi: {symbol, days:30}.',
+      context: `Kullanım: Jev tur state'ine kompakt performans özeti koymak. Veri kaynağı: %APPDATA%\\beast\\finance\\ogrenme.json (finLearnApi stats/list ile aynı şema). Semboller: ${syms}.`,
+    },
+  };
+  const spec = specs[String(c.choice)];
+  if (!spec) return;
+  agent.tsToolReqAt = now;
+  try {
+    const r = await engine._toolRequest({ task: spec.task, context: spec.context }, sidS);
+    lines.push(
+      r && r.ok
+        ? `- 🧰 Araç isteği TOOL botuna gönderildi: ${spec.name} (asenkron — hazır olunca rapor düşer)`
+        : `- araç isteği başarısız — ${(r && r.error) || 'hata'}`
+    );
+  } catch (e) {
+    lines.push('- araç isteği hatası: ' + String((e && e.message) || e));
+  }
+}
+
 function finTsSchedule(sid, agent, sec) {
   if (!agent || !financeState.agents.has(String(sid))) return;
   clearTimeout(agent.timer);
@@ -13925,12 +14077,15 @@ async function finTypeSafeRound(sid, agent) {
     }
     /* VERİ: hesap + pozisyonlar + sembol fiyat/gösterge — hepsi KOD ile toplanır,
        yalnız TypeSafe'e gönderilir; hiçbir LLM çağrısı yapılmaz */
-    const [accR, posR] = await Promise.all([
+    const [accR, posR, ordR] = await Promise.all([
       financetools.handlers.mt5_account({}),
       financetools.handlers.mt5_positions({}),
+      financetools.handlers.mt5_orders({}).catch(() => null),
     ]);
     const account = (accR && accR.account) || {};
     const posList = (posR && posR.positions) || [];
+    /* BEKLEYEN EMİRLER: pozisyon slotunu paylaşır (aşırı birikmeyi önler) */
+    const pendCount = (ordR && Array.isArray(ordR.orders) ? ordR.orders.length : 0);
     const market = {};
     for (const sym of symbols) {
       const tf = finTsPickTf(agent, sym);
@@ -13954,6 +14109,11 @@ async function finTypeSafeRound(sid, agent) {
         acik_pozisyon: posList.length,
       },
       limitler: { max_pozisyon: Number(f.maxPositions) || 3, min_lot: Number(f.minLot) || 0.01, max_lot: Number(f.maxLot) || 0.1 },
+      bekleyen_emir: pendCount,
+      /* MEVCUT ALARMLAR: Jev aynı seviyeye tekrar alarm kurmasın (kod yine kapılar) */
+      alarmlar: (financeState.alerts || []).slice(0, 8).map((a) => ({
+        sembol: a.symbol, yon: a.direction, fiyat: a.price, mod: a.once ? 'tek' : 'tekrarlı',
+      })),
       /* AÇIK POZİSYONLAR: R/kâr R'si/en iyi R + koruma bayrakları — Jev'in
          kapatma/kısmi/SL kararları bu bağlamla verilir (finTsPosState) */
       pozisyonlar: posList.map((p) => finTsPosState(p)),
@@ -13962,6 +14122,10 @@ async function finTypeSafeRound(sid, agent) {
       /* KALİBRASYON: öğrenilmiş eşik + risk çarpanı + kazandıran kurallar */
       kalibrasyon: symbols.map((s) => finTsCalState(s, market[s] && market[s].tf)).filter(Boolean).join('\n') || '(kalibrasyon verisi henüz yok)',
       ekip_yanitlari: finTsFeedText(6),
+      /* SAHİBİN TALİMATI (Trade Ajanı kartı): Jev bunu BİRİNCİL kural kabul eder;
+         talimat "zorunlu giriş" içeriyorsa kod eşikleri devre dışı bırakır. */
+      sahip_talimati: finTsStrategyText() || '(yok — temel teknik okuma)',
+      talimat_modu: finTsMandatoryEntry() ? 'ZORUNLU GİRİŞ — bu turda işlem açmak zorunlu (bekle yok); yönü sen seç' : '',
     };
     for (const sym of symbols) {
       const d = market[sym];
@@ -13983,21 +14147,62 @@ async function finTypeSafeRound(sid, agent) {
         if (symbols.includes(s)) posBySym[s] = p;
       }
       const questions = {};
+      const talimatZorunlu = finTsMandatoryEntry();
       symbols.forEach((sym, i) => {
         questions['yon_' + i] = {
           type: 'choice',
-          instructions: `${sym} ${market[sym].tf} grafiğinde verilen fiyat, gösterge, pozisyon, öğrenme geçmişi ve ekip yanıtlarına göre kısa vadeli doğru aksiyon nedir? Emin değilsen bekle.`,
-          criteria: {
-            buy: 'LONG aç — yükseliş teyidi var (yapı/momentum/EMA eğimi destekliyor)',
-            sell: 'SHORT aç — düşüş teyidi var',
-            bekle: 'İşlem açma — teyit yok, belirsiz ya da riskli',
-          },
+          instructions: talimatZorunlu
+            ? `${sym} ${market[sym].tf}: SAHİBİN TALİMATI GEREĞİ bu turda işlem açmak ZORUNDASIN — 'bekle' YOK. Yönü sen seç: gösterge/momentum/yapıya göre en olası yön (buy/sell). Sahip talimatı state'tedir, birincil kuraldır.`
+            : `${sym} ${market[sym].tf} grafiğinde verilen fiyat, gösterge, pozisyon, öğrenme geçmişi, ekip yanıtları ve SAHİP TALİMATINA göre kısa vadeli doğru aksiyon nedir? Emin değilsen bekle.`,
+          criteria: talimatZorunlu
+            ? {
+                buy: 'LONG aç — bu turda giriş zorunlu, yükseliş tarafı daha olası',
+                sell: 'SHORT aç — bu turda giriş zorunlu, düşüş tarafı daha olası',
+              }
+            : {
+                buy: 'LONG aç — yükseliş teyidi var (yapı/momentum/EMA eğimi destekliyor)',
+                sell: 'SHORT aç — düşüş teyidi var',
+                bekle: 'İşlem açma — teyit yok, belirsiz ya da riskli',
+              },
         };
         questions['teyit_' + i] = {
           type: 'noul',
           instructions: `${sym} fiyat yapısı ve momentum, 'yon_' + ${i} kararını gerçekten destekliyor mu?`,
           criteria: { true: 'Net destekliyor', false: 'Zayıf/çelişkili' },
         };
+        /* GİRİŞ TİPİ + RİSK PROFİLİ: seviyeleri KOD hesaplar (ATR/EMA), kararı Jev verir.
+           "Zorunlu giriş" modunda bekleyen emir sorulmaz — giriş garanti olsun diye market. */
+        if (!talimatZorunlu) {
+          questions['emir_' + i] = {
+            type: 'choice',
+            instructions: `${sym} sinyali onaylanırsa giriş tipi ne olsun? Anında mı gir (market), geri çekilme mi bekle (limit), kırılım teyidi mi bekle (stop)? Giriş seviyesini kod ATR/EMA'dan hesaplar.`,
+            criteria: {
+              market: 'Anında piyasadan gir — kaçırma riski yok, fiyat şimdiki',
+              limit: 'Geri çekilmede limit emir — daha iyi fiyat bekle (ATR/EMA seviyesi)',
+              stop: 'Kırılımda stop emir — momentum teyidi bekle (ATR seviyesi)',
+            },
+          };
+        }
+        questions['risk_' + i] = {
+          type: 'choice',
+          instructions: `${sym} için SL/TP profili? Seviyeleri kod ATR'den hesaplar; volatilite ve öğrenme geçmişini dikkate al.`,
+          criteria: {
+            siki: 'Sıkı: SL 1.0×ATR · TP 2.0×ATR — hızlı çık, yüksek isabet',
+            dengeli: 'Dengeli: SL 1.5×ATR · TP 2.5×ATR',
+            genis: 'Geniş: SL 2.0×ATR · TP 3.5×ATR — trendi taşı, gürültüye dayan',
+          },
+        };
+        questions['alarm_' + i] = {
+          type: 'choice',
+          instructions: `${sym} için fiyat alarmı kurulsun mu? Alarm SEVİYESİ gelince tur beklemeden uyanırsın (tek seferlik). Gereksizse yok seç.`,
+          criteria: {
+            yok: 'Alarm gerekmez',
+            ust_kirilim: 'Üst kırılım (son 20 mum tepesi) üzerinde alarm',
+            alt_kirilim: 'Alt kırılım (son 20 mum dibi) altında alarm',
+            yukari_atr: 'Fiyat +0.5×ATR üzerinde alarm',
+            asagi_atr: 'Fiyat -0.5×ATR altında alarm',
+          },
+        };
         if (posBySym[sym]) {
           const pp = posBySym[sym];
           const ps = finTsPosState(pp);
@@ -14032,6 +14237,17 @@ async function finTypeSafeRound(sid, agent) {
           };
         }
       });
+      /* ARAÇ İHTİYACI (tur düzeyi): eksik araç varsa TOOL botuna yazdırılır */
+      questions['arac'] = {
+        type: 'choice',
+        instructions: 'Bu turda eksik bir ARAÇ var mı? Varsa TOOL botuna yazdırılır (asenkron; rapor AJAN DM\'e düşer, ajan beklemez). İhtiyaç yoksa yok seç.',
+        criteria: {
+          yok: 'Araç isteği yok',
+          haber: 'Haber/makro veri aracı (ekonomik takvim + haber akışı)',
+          korelasyon: 'Korelasyon/maruziyet aracı (yönlü risk matrisi)',
+          rapor: 'Sembol performans raporu aracı (öğrenme deposundan özet)',
+        },
+      };
       let ans = null;
       try {
         ans = await finTsAsk(state, questions);
@@ -14050,7 +14266,10 @@ async function finTypeSafeRound(sid, agent) {
         if (!financeState.agents.has(sidS)) return;
         const c = finTsChoice(ans, 'yon_' + i);
         const conf = finTsNoul(ans, 'teyit_' + i);
+        const confVal = conf == null ? 0 : conf;
         const pos = posBySym[sym];
+        /* JEV FİYAT ALARMI: seçilen seviyeye tek seferlik alarm (kurulumu kod yapar) */
+        try { await finTsSetAlarm(sidS, agent, sym, market[sym], ans, i, lines); } catch {}
         /* ÖĞRENİLMİŞ EŞİK + RİSK ÇARPANI: kalibrasyon verisi biriktikçe kod
            eşiği ve riski kendisi ayarlar (sistem öğrendikçe o karar verir) */
         const cal = finTsCalibration(sym, market[sym].tf);
@@ -14074,42 +14293,85 @@ async function finTypeSafeRound(sid, agent) {
           lines.push(`- ${sym}: ${finTsFmtChoice(c)} → BEKLE`);
           continue;
         }
-        if (!(c.p >= thAction) || c.p - c.second < FIN_TS_MARGIN_P) {
-          lines.push(`- ${sym}: ${finTsFmtChoice(c)} → öğrenilmiş eşik p≥${thAction.toFixed(2)}/fark altı, BEKLE`);
-          continue;
-        }
-        if (conf == null || conf < FIN_TS_CONFIRM_P) {
-          lines.push(`- ${sym}: ${finTsFmtChoice(c)} · teyit=${conf == null ? 'yok' : conf.toFixed(2)} < ${FIN_TS_CONFIRM_P} → BEKLE`);
-          continue;
+        /* SAHİP TALİMATI "zorunlu giriş" diyorsa eşik/teyit kapıları UYGULANMAZ
+           (talimat birincil kural) — yön Jev'in seçimidir. */
+        if (!talimatZorunlu) {
+          if (!(c.p >= thAction) || c.p - c.second < FIN_TS_MARGIN_P) {
+            lines.push(`- ${sym}: ${finTsFmtChoice(c)} → öğrenilmiş eşik p≥${thAction.toFixed(2)}/fark altı, BEKLE`);
+            continue;
+          }
+          if (conf == null || conf < FIN_TS_CONFIRM_P) {
+            lines.push(`- ${sym}: ${finTsFmtChoice(c)} · teyit=${conf == null ? 'yok' : conf.toFixed(2)} < ${FIN_TS_CONFIRM_P} → BEKLE`);
+            continue;
+          }
         }
-        if (opened >= 1 || posList.length >= (Number(f.maxPositions) || 3)) {
-          lines.push(`- ${sym}: sinyal güçlü (${c.choice} p=${c.p.toFixed(2)}) ama pozisyon sınırı dolu — bu tur açılmadı`);
+        if (opened >= 1 || posList.length + pendCount >= (Number(f.maxPositions) || 3)) {
+          lines.push(`- ${sym}: sinyal güçlü (${c.choice} p=${c.p.toFixed(2)}) ama pozisyon+bekleyen emir sınırı dolu — bu tur açılmadı`);
           continue;
         }
-        /* SL/TP KOD ile: ATR(14) tabanlı — tip ve seviyeler deterministik */
+        /* GİRİŞ TİPİ + RİSK PROFİLİ (JEV kararı) — seviyeleri KOD hesaplar */
         const row = market[sym].row || {};
-        const price = c.choice === 'buy' ? Number(row.ask) || Number(row.bid) : Number(row.bid) || Number(row.ask);
-        if (!(price > 0)) { lines.push(`- ${sym}: fiyat okunamadı`); continue; }
+        const entryRef = c.choice === 'buy' ? Number(row.ask) || Number(row.bid) : Number(row.bid) || Number(row.ask);
+        if (!(entryRef > 0)) { lines.push(`- ${sym}: fiyat okunamadı`); continue; }
         const atr = Number(market[sym].ind && market[sym].ind.atr14) || 0;
-        const slDist = Math.max(atr > 0 ? atr * 1.5 : price * 0.003, price * 0.0004);
-        const tpDist = Math.max(atr > 0 ? atr * 2.5 : price * 0.006, slDist * 1.2);
         const digits = Math.max(0, Math.min(8, Number(row.digits) || 2));
         const rnd = (v) => Number(Number(v).toFixed(digits));
-        const sl = rnd(c.choice === 'buy' ? price - slDist : price + slDist);
-        const tp = rnd(c.choice === 'buy' ? price + tpDist : price - tpDist);
+        const point = Number(row.point) > 0 ? Number(row.point) : Math.pow(10, -digits);
+        const stopsPts = Number(row.trade_stops_level) || 0;
+        const minDist = stopsPts > 0 ? (stopsPts + 1) * point : point;
+        const isBuy = c.choice === 'buy';
+        /* RİSK PROFİLİ: SL/TP çarpanlarını Jev seçer, seviyeleri kod kurar */
+        const profC = finTsChoice(ans, 'risk_' + i);
+        const profKey = ['siki', 'dengeli', 'genis'].includes(String(profC && profC.choice)) ? String(profC.choice) : 'dengeli';
+        const prof = { siki: [1.0, 2.0], dengeli: [1.5, 2.5], genis: [2.0, 3.5] }[profKey];
+        const slDist = Math.max(atr > 0 ? atr * prof[0] : entryRef * 0.003, entryRef * 0.0004);
+        const tpDist = Math.max(atr > 0 ? atr * prof[1] : entryRef * 0.006, slDist * 1.2);
+        /* EMİR TİPİ: market / limit / stop — Jev seçer, giriş seviyesini kod kurar.
+           Zorunlu giriş modunda MARKET sabittir (bekleyen emir açık pozisyon değildir). */
+        const emirC = talimatZorunlu ? null : finTsChoice(ans, 'emir_' + i);
+        const emirKind = talimatZorunlu ? 'market' : (emirC && emirC.p >= FIN_TS_CONFIRM_P && emirC.p - emirC.second >= FIN_TS_MARGIN_P ? String(emirC.choice) : 'market');
+        let orderType = 'market';
+        let entry = entryRef;
+        if (emirKind === 'limit') {
+          const pull = Math.max(atr > 0 ? atr * 0.5 : entryRef * 0.0015, minDist + point);
+          const atrLvl = isBuy ? entryRef - pull : entryRef + pull;
+          const ema = Number(market[sym].ind && market[sym].ind.ema50);
+          const emaOk =
+            isFinite(ema) && ema > 0 &&
+            (isBuy ? ema < entryRef - minDist : ema > entryRef + minDist) &&
+            Math.abs(entryRef - ema) <= Math.max(atr * 2, entryRef * 0.006);
+          entry = rnd(emaOk ? ema : atrLvl);
+          orderType = isBuy ? 'buy_limit' : 'sell_limit';
+        } else if (emirKind === 'stop') {
+          const breakDist = Math.max(atr > 0 ? atr * 0.25 : entryRef * 0.001, minDist + point);
+          entry = rnd(isBuy ? entryRef + breakDist : entryRef - breakDist);
+          orderType = isBuy ? 'buy_stop' : 'sell_stop';
+        }
+        const sl = rnd(isBuy ? entry - slDist : entry + slDist);
+        const tp = rnd(isBuy ? entry + tpDist : entry - tpDist);
         const riskBase = Number(f.riskPerTradePct) > 0 ? Number(f.riskPerTradePct) : 0.5;
         const riskPct = Math.max(0.1, Math.min(2, Math.round(riskBase * cal.riskMult * 100) / 100));
+        const emirLabel =
+          orderType === 'market' ? 'MARKET' :
+          isBuy && orderType === 'buy_limit' ? 'BUY LIMIT' :
+          !isBuy && orderType === 'sell_limit' ? 'SELL LIMIT' :
+          isBuy && orderType === 'buy_stop' ? 'BUY STOP' : 'SELL STOP';
         const r = await financetools.handlers.mt5_trade(
           {
             symbol: sym,
             side: c.choice,
-            type: 'market',
+            type: orderType,
+            ...(orderType === 'market' ? {} : { price: entry }),
             sl,
             tp,
             riskPct,
             timeframe: market[sym].tf,
             comment: 'TS',
-            reason: `TypeSafe: yön ${c.choice} p=${c.p.toFixed(2)} fark=${(c.p - c.second).toFixed(2)} teyit=${conf.toFixed(2)}`,
+            reason:
+              `TypeSafe: yön ${c.choice} p=${c.p.toFixed(2)} fark=${(c.p - c.second).toFixed(2)} teyit=${confVal.toFixed(2)}` +
+              (orderType !== 'market' ? ` · ${orderType} @${entry}` : '') +
+              ` · ${profKey} profil` +
+              (talimatZorunlu ? ' · SAHİP TALİMATI (zorunlu giriş)' : ''),
           },
           { sessionId: sidS }
         );
@@ -14127,24 +14389,31 @@ async function finTypeSafeRound(sid, agent) {
               action: c.choice,
               p: c.p,
               pSecond: c.second,
-              confirm: conf,
+              confirm: confVal,
               hour: new Date().getHours(),
               emaAlign: ind.ema50 != null && ind.ema200 != null ? (ind.ema50 > ind.ema200) === (c.choice === 'buy') : null,
               rsi: ind.rsi14,
-              atrPct: atr > 0 && price > 0 ? atr / price : null,
+              atrPct: atr > 0 && entryRef > 0 ? atr / entryRef : null,
               riskPct,
+              orderType,
             });
           } catch {}
           lines.push(
-            `- ${sym}: ⚡ MARKET ${c.choice.toUpperCase()} açıldı (lot ${r.opened && r.opened.volume}, SL ${sl}, TP ${tp}, risk %${riskPct}${cal.riskMult !== 1 ? ` ×${cal.riskMult}` : ''}) · p=${c.p.toFixed(2)} teyit=${conf.toFixed(2)} · tf=${market[sym].tf}` +
+            (orderType === 'market'
+              ? `- ${sym}: ⚡ MARKET ${c.choice.toUpperCase()} açıldı (lot ${r.opened && r.opened.volume}, SL ${sl}, TP ${tp}, risk %${riskPct}${cal.riskMult !== 1 ? ` ×${cal.riskMult}` : ''})`
+              : `- ${sym}: ⏳ ${emirLabel} emri kondu @${entry} (${profKey} profil, SL ${sl}, TP ${tp}, risk %${riskPct})`) +
+              ` · p=${c.p.toFixed(2)} teyit=${confVal.toFixed(2)} · tf=${market[sym].tf}` +
+              (talimatZorunlu ? ' · TALİMAT: zorunlu giriş' : '') +
               (thAction !== FIN_TS_DEFAULT_TH.action ? ` · öğrenilmiş eşik p≥${thAction.toFixed(2)}` : '')
           );
         } else if (r && r.ok && r.shadow) {
-          lines.push(`- ${sym}: SHADOW mod — emir gönderilmedi (${c.choice} p=${c.p.toFixed(2)})`);
+          lines.push(`- ${sym}: SHADOW mod — emir gönderilmedi (${emirLabel} ${c.choice} p=${c.p.toFixed(2)})`);
         } else {
           lines.push(`- ${sym}: ${c.choice.toUpperCase()} sinyali reddedildi — ${(r && r.error) || 'hata'}`);
         }
       }
+      /* JEV ARAÇ İSTEĞİ (tur düzeyi): eksik araç varsa TOOL botuna asenkron yazdır */
+      try { await finTsToolRequest(sidS, agent, ans, lines); } catch {}
       finTsPost(
         sidS,
         agent,
@@ -14185,6 +14454,17 @@ async function finTypeSafeRound(sid, agent) {
         criteria: { true: 'Risk var — dikkat/engel', false: 'Risk normal' },
       };
     });
+    /* ARAÇ İHTİYACI (tur düzeyi): eksik araç varsa TOOL botuna yazdırılır */
+    questions['arac'] = {
+      type: 'choice',
+      instructions: 'Bu turda rolün için eksik bir ARAÇ var mı? Varsa TOOL botuna yazdırılır (asenkron; rapor AJAN DM\'e düşer, ajan beklemez). İhtiyaç yoksa yok seç.',
+      criteria: {
+        yok: 'Araç isteği yok',
+        haber: 'Haber/makro veri aracı (ekonomik takvim + haber akışı)',
+        korelasyon: 'Korelasyon/maruziyet aracı (yönlü risk matrisi)',
+        rapor: 'Sembol performans raporu aracı (öğrenme deposundan özet)',
+      },
+    };
     let ans = null;
     try {
       ans = await finTsAsk(state, questions);
@@ -14206,12 +14486,15 @@ async function finTypeSafeRound(sid, agent) {
         (rk == null ? '' : ` · risk=${rk.toFixed(2)}${rk >= 0.55 ? ' ⚠' : ''}`)
       );
     });
+    /* JEV ARAÇ İSTEĞİ (rol ajanı): eksik araç varsa TOOL botuna asenkron yazdır */
+    try { await finTsToolRequest(sidS, agent, ans, lines); } catch {}
     finTsPost(sidS, agent, `🧠 TypeSafe analiz (LLM yok — girdi yalnız TypeSafe):\n` + lines.join('\n'), symbols.join(','));
   } catch (e) {
     try { financeLog('[typesafe] tur hatası (' + sidS + '): ' + String((e && e.message) || e)); } catch {}
   } finally {
     agent.tsBusy = false;
-    finTsSchedule(sidS, agent, finPaceSec());
+    /* RİTİM: sahip talimatı M1/M5 diyorsa ana trader turları ona göre hızlanır */
+    finTsSchedule(sidS, agent, finTsStrategyPaceSec(agent));
     if (agent.main && financeState.agents.has(sidS)) finPush('trader', { state: 'idle', round: agent.round, mode: 'typesafe' });
   }
 }
@@ -14235,7 +14518,7 @@ function finAgentRound(sid, opts) {
   }
   /* JEV-ONLY (SABİT): finance ajanları LLM HİÇ kullanmaz — tur deterministik
      TypeSafe hattıyla koşar (girdi yalnız TypeSafe'e gider, cevaplar AJAN
-     DM'e düşer, emirler yalnız market buy/sell) */
+     DM'e düşer; emir tipi/seviyeler/alarm/araç isteği Jev kararı + kod) */
   if (finTsAgentMode(agent)) {
     finTypeSafeRound(String(sid), agent).catch(() => {});
     return;