fix(codex-bridge): close the gaps an independent review found

- One decision per real turn: a turn starts with a user message after the
  previous final answer; tool steps, messages typed mid-turn, a lone "."
  and compaction keep the combo. Works without prompt_cache_key too.
- The virtual Otomatik name never reaches the gateway (stage off or error
  -> last choice or targets.zor); prefilter.target may not be it.
- finishCheck: at most once per turn; a broken, empty or refused retry
  delivers the already approved first answer.
- Layer window filter: only trusted windows, never the last layer.
- Correction channel only on always-pass targets while checks are on;
  Sesli-Hizli-Zeki stays always-pass by default; a >256 KB SSE frame
  passes unfiltered instead of breaking the stream.
- Turn-start questions wait in the local queue no longer than their
  timeout; decision-turn memory under a lock with refreshed order.
- Dify fetch refuses redirects (the app key never moves host); the
  rules file write retries a Windows sharing violation.
- An unreadable settings file no longer breaks every request.
- TypeScript accepts only https:// URLs the bridge accepts;
  finishCheck.timeoutSeconds (unused) removed.

Tests: 310 bridge tests, 36 electron tests; side-bridge live run for the
turn, prefilter (incl. decision timeout) and finish-check paths.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

.gitea/workflows/ci.yml

@@ -23,6 +23,9 @@ jobs:
         run: |
           set -eu
           test "$(git rev-parse HEAD)" = "$GITHUB_SHA"
+          apt-get update
+          apt-get install -y --no-install-recommends ripgrep
+          rg --version
           python3 -m venv "$RUNNER_TEMP/bootstrap"
           "$RUNNER_TEMP/bootstrap/bin/pip" install uv
           "$RUNNER_TEMP/bootstrap/bin/uv" venv --python 3.11 "$RUNNER_TEMP/ci-venv"
@@ -32,8 +35,12 @@ jobs:
           "$RUNNER_TEMP/ci-venv/bin/python" -m pytest tests/tools/test_protected_instruction_unattended.py tests/tools/test_file_write_safety.py tests/tools/test_computer_use_approval_isolation.py tests/cli/test_cli_approval_ui.py tests/cli/test_single_query_session_finalize.py -q -p no:cacheprovider -rf
       - name: Codex bridge regression tests
         run: '"$RUNNER_TEMP/ci-venv/bin/python" -m unittest discover -s apps/desktop/assets/codex-bridge'
+      - name: Managed Python update preservation
+        run: '"$RUNNER_TEMP/ci-venv/bin/python" -m pytest tests/test_install_ps1_reuse_healthy_venv.py tests/test_install_ps1_python_fallback_venv.py -q -p no:cacheprovider -rf'
+      - name: Project scoped and bounded search regressions
+        run: '"$RUNNER_TEMP/ci-venv/bin/python" -m pytest tests/tools/test_search_project_scope.py tests/tools/test_search_files_cpu_windows.py tests/tools/test_search_zero_match_and_multipath.py tests/tools/test_search_giant_line_containment.py tests/tools/test_search_budget_truncation.py -q -p no:cacheprovider -rf'
       - name: Native watch and speech mux pytest regressions
-        run: '"$RUNNER_TEMP/ci-venv/bin/python" -m pytest apps/desktop/assets/codex-bridge/test_bekci_watch.py apps/desktop/assets/codex-bridge/test_native_speech_mux.py -q -p no:cacheprovider -rf'
+        run: '"$RUNNER_TEMP/ci-venv/bin/python" -m pytest apps/desktop/assets/codex-bridge/test_bekci_watch.py apps/desktop/assets/codex-bridge/test_native_speech_mux.py apps/desktop/assets/codex-bridge/test_live_limits.py -q -p no:cacheprovider -rf'
       - name: Mobile and desktop startup regression tests
         run: |
           npm install --prefix "$RUNNER_TEMP/mobile-tests" --no-save --ignore-scripts --no-audit --no-fund --legacy-peer-deps vitest@4.1.10 ws@8.21.1

README.AITURK.md

@@ -25,6 +25,8 @@ ayrıntı seviyesi, korunacak mesajlaşmalar, yüzde/token bütçesi ve otomatik
 seçimini sunar. Varsayılanlar: Gemini 3.8 Flash High, yedek Gemini 3 Flash,
 10 mesajlaşma, geçişte %70, otomatik tetiklemede %70 ve sonrasında %50.
 Kapasite bağlantıdan gelen model bilgisiyle hesaplanır; 272K genel tavan yoktur.
+`/models` içindeki doğrulanmış sayısal bağlam bilgisi, model adından çıkarılan
+yerel varsayılandan önce gelir; gözlenmiş daha düşük bir gerçek sınır korunur.
 Girdi hesabı talimatlar ve araçları da içeren temkinli bir token tahminidir.
 
 Abonelik modellerinin kendi aralarındaki istekler ve GPT-Live ses yolu özgün
@@ -58,8 +60,9 @@ npm run builder --workspace=apps/desktop -- --win nsis --x64 --publish never
 
 Dağıtılacak derleme temiz, yayımlanmış Git commit'inden üretilmelidir. İlk açılış
 ajan kurulumunu paketteki `install-stamp.json` commit'ine sabitler. Windows
-imzası ve temiz kurulum doğrulanmadan bir paket doğrulanmış üretim sürümü diye
-sunulmamalıdır. macOS ve Linux paketleri bu beta kapsamında doğrulanmamıştır.
+paketleri imzasız EXE/ZIP olarak yayımlanır; SHA-256 ve gerçek Windows çalıştırma
+kontrolü gereklidir. Kullanıcı açıkça istemeden imzalama yapılmaz. macOS ve Linux
+paketleri bu beta kapsamında doğrulanmamıştır.
 
 ## Lisans ve kaynak
 

agent/search_policy.py

@@ -8,6 +8,66 @@ path; broad diagnostic probes should apply this policy to recursive walks.
 
 from __future__ import annotations
 
+from pathlib import Path
+
+SEARCH_RG_THREADS = 2
+SEARCH_MAX_CONCURRENT = 2
+
+_PROJECT_MARKERS = ('.git', '.hg', 'pyproject.toml', 'package.json',
+                    'Cargo.toml', 'go.mod', 'CMakeLists.txt')
+
+
+def _project_root(path):
+    """Prefer the enclosing repository over nested monorepo packages."""
+    package = None
+    for parent in (path, *path.parents):
+        if (parent / '.git').exists() or (parent / '.hg').exists():
+            return parent
+        if package is None and any((parent / marker).exists() for marker in _PROJECT_MARKERS):
+            package = parent
+    return package
+
+
+def local_search_scope(path, cwd, home):
+    """Resolve broad local roots without starting a recursive search process.
+
+    Returns (root, notice, error). Only one level of candidate directories is
+    inspected; no repository-wide discovery is needed to reject an umbrella.
+    Real paths prevent symlink aliases from bypassing broad-root detection.
+    """
+    root = Path(path)
+    if not root.is_absolute():
+        root = Path(cwd) / root
+    root = root.resolve()
+    if not root.is_dir():
+        return path, None, None
+    home = Path(home).resolve()
+    project = _project_root(Path(cwd).resolve())
+    root_project = _project_root(root)
+    if root_project is not None:
+        return path, None, None
+    candidates = []
+    try:
+        # Bound metadata work even in directories containing many entries.
+        from itertools import islice
+        for child in islice(root.iterdir(), 256):
+            if child.name in SEARCH_PRUNE_DIR_NAMES or not child.is_dir():
+                continue
+            if any((child / marker).exists() for marker in _PROJECT_MARKERS):
+                candidates.append(str(child))
+    except OSError:
+        pass
+    broad = (root == Path(root.anchor) or root == home or root in home.parents
+             or len(candidates) > 1 or (project is not None and root in project.parents))
+    if not broad:
+        return path, None, None
+    if project is not None and root in project.parents:
+        chosen = str(project)
+        return chosen, f'Search scoped to current project: {chosen}. Set allow_broad=true for the requested umbrella.', None
+    choices = ', '.join(sorted(candidates)[:12]) or 'choose an explicit project directory'
+    return path, None, ('Search scope needed: requested root spans projects or a home/drive. '
+                        f'Candidates: {choices}. Set allow_broad=true only for an intentional broad search.')
+
 
 # Keep this policy conservative and name-based so it works for local and remote
 # shell backends alike. The same set is used by context discovery and search

apps/desktop/assets/codex-bridge/README.md

@@ -27,6 +27,45 @@ Run: `python bridge.py --home <data dir> --hermes-home <agent home>`. The IDE wr
 
 Tests: `python -m unittest discover` in this directory.
 
+## Version 19: decision stages (14 October 2026)
+
+The decision model (Jev or another System One compatible service such as Celeris) can now be asked at
+several stages. Every new stage is switched on in Settings → Kademeli Geçiş and starts disabled, so an
+upgrade changes no behaviour by itself. The decision model never writes text; an unreachable or invalid
+decision always keeps the current path.
+
+- `jev-settings.json` schema 2 adds `watchModels`, `prefilter`, `autoRoute`, `finishCheck`,
+  `verifierCheck` and `policy`. A schema 1 file is filled from `jev-settings-defaults.json`.
+  The default chain is `Katman-1 → Katman-2 → Katman-3`; `Katman-3`, `Chat-Model`,
+  `bekci-sesli-bekci` and `Sesli-Hizli-Zeki` always pass.
+- **Correction channel** (`watchModels`): the Bekçi watch sideband is no longer bound to the hard-coded
+  name `Sesli-Hizli-Zeki`; any exact target in the list owns it, but only while it always passes the check
+  (a checked answer may be replaced by a layer, and a receipt must not belong to an answer the user never saw).
+  A single SSE frame above 256 KB no longer breaks the stream; the rest of the stream passes unfiltered.
+- **Refusal pre-check** (`prefilter`): at the start of a turn, "would a mainstream model refuse or water
+  this down?". If yes, the step starts at `prefilter.target` instead of collecting a refusal first.
+- **Automatic model** (`autoRoute`): a virtual `ide/<model>` entry ("Otomatik") in the Codex list. A new turn
+  (a user message after the previous final answer) gets one decision call (hard? research?) and goes to
+  the configured combo. Tool steps, messages typed while the turn runs, a lone "." and compaction stay on
+  the same combo, because switching providers mid-turn breaks encrypted history. When the stage is off or
+  fails, the virtual name never reaches the gateway: the last choice or `targets.zor` is used. The user's
+  explicit model choice is never changed by this stage.
+- Both turn-start questions go in one call; the wait, including the local queue, is bounded by
+  `timeoutSeconds` (default 3 s).
+- **Layer window filter**: a layer whose trusted context window (pencere.bekci_calisir) cannot hold the
+  request is skipped. The last link of the chain is never skipped.
+- **Early finish check** (`finishCheck`): asked in the same call as the refusal check on a final answer.
+  If the answer stopped early or claimed success without evidence, it goes back to the same model with
+  `finishCheck.note`, at most once per turn. If the retry breaks, comes back empty or fails the check, the
+  first (already approved) answer is delivered.
+- **Rules from Dify** (`policy.source = dify`, `karar_politikasi.py`): the stage questions, thresholds and
+  combo choices may come from a Dify workflow's `kurallar` output. Fetched in the background every
+  `refreshMinutes`, validated against the local settings, last good copy kept in `jev-policy.json`.
+  The transition chain and the always-pass list stay local. A turn never waits for Dify, and a redirect
+  from the Dify endpoint is refused so the app key never travels to another host.
+- **Workflow reviewer check** (`verifierCheck`, `karar_sor.py`): the Codex dynamic-workflow acceptance
+  step asks whether a reviewer approved without concrete evidence; if so acceptance is blocked.
+
 ## Version 11: isolated routes and cross-provider preparation
 
 - Pure subscription chats and native voice retain their ChatGPT route. Added

apps/desktop/assets/codex-bridge/bridge.py

@@ -32,9 +32,10 @@ import time
 import urllib.error
 import urllib.request
 import gecis_context
+import terminal_stream
 
 HERE = os.path.dirname(os.path.abspath(__file__))
-SURUM = "14"         # AITURK IDE'nin bekledigi kopru surumu (codex-link-config.ts CODEX_BRIDGE_VERSION)
+SURUM = "19"         # AITURK IDE'nin bekledigi kopru surumu (codex-link-config.ts CODEX_BRIDGE_VERSION)
 try:
     with open(os.path.abspath(__file__), "rb") as _f:
         KOD = hashlib.sha256(_f.read()).hexdigest()[:8]
@@ -348,6 +349,36 @@ class H(http.server.BaseHTTPRequestHandler):
             self.end_headers()
             self.wfile.write(hata)
             return True
+        observer = None
+        first_chunks = []
+        failure_key = getattr(self, "_failure_key", None)
+        if (hedef == KOPRU and failure_key is not None and durum == 200
+                and "text/event-stream" in yanit.headers.get("Content-Type", "")
+                and yanit.headers.get("Content-Encoding", "identity") == "identity"):
+            observer = terminal_stream.Observer()
+            if not started:
+                # Inspect only until the first SSE frame/comment. Keep normal
+                # streaming and heartbeats; an error-only response can still
+                # return a truthful HTTP failure before headers are committed.
+                try:
+                    while True:
+                        first = yanit.read1(4096)
+                        if not first:
+                            break
+                        first_chunks.append(first)
+                        observer.feed(first)
+                        if observer.error and not observer.payload_seen:
+                            yanit.close()
+                            self._json(400, terminal_stream.error_body(observer.error))
+                            return True
+                        if observer.comment_seen or observer.payload_seen or sum(map(len, first_chunks)) >= observer.LIMIT:
+                            break
+                except (OSError, http.client.HTTPException):
+                    # A transport interruption without an explicit provider
+                    # failure keeps the client's existing recovery behavior.
+                    yanit.close()
+                    self.close_connection = True
+                    return True
         if not started:
             self.send_response(durum)
             for k, v in yanit.headers.items():
@@ -359,6 +390,10 @@ class H(http.server.BaseHTTPRequestHandler):
         event_tail = b""
         completed = False
         try:
+            for first in first_chunks:
+                toplam += len(first)
+                self.wfile.write(b"%x\r\n" % len(first) + first + b"\r\n")
+                self.wfile.flush()
             while True:
                 try:
                     parca = yanit.read1(4096)      # gelen kadarini hemen verir; bekletmez
@@ -370,6 +405,8 @@ class H(http.server.BaseHTTPRequestHandler):
                 if not parca:
                     break
                 toplam += len(parca)
+                if observer is not None:
+                    observer.feed(parca)
                 if getattr(self, "_native_return_scope", None):
                     event_tail += parca
                     while b"\n" in event_tail:
@@ -382,6 +419,9 @@ class H(http.server.BaseHTTPRequestHandler):
                                 pass
                 self.wfile.write(b"%x\r\n" % len(parca) + parca + b"\r\n")
                 self.wfile.flush()
+            if observer is not None and observer.error and not observer.completed:
+                self.server.failure_replays.remember(failure_key, observer.error)
+                log(f"{tag} terminal worker error; identical automatic replay will return HTTP 400")
             self.wfile.write(b"0\r\n\r\n")
             self.wfile.flush()
         except (ConnectionAbortedError, BrokenPipeError, ConnectionResetError):
@@ -453,6 +493,7 @@ class H(http.server.BaseHTTPRequestHandler):
 
     def _isle(self):
         self._native_return_scope = None
+        self._failure_key = None
         with kilit:
             sira[0] += 1
             n = sira[0]
@@ -479,20 +520,32 @@ class H(http.server.BaseHTTPRequestHandler):
                     req = {}
             except Exception:
                 req = {}
+            if external:
+                self._failure_key = terminal_stream.request_key(req or {"raw": govde.hex()}, self.headers)
+                previous_failure = self.server.failure_replays.take(self._failure_key)
+                if previous_failure:
+                    log(f"[{n} {model}] terminal worker error replay stopped before upstream request")
+                    return self._json(400, terminal_stream.error_body(previous_failure))
             thread = str(req.get("prompt_cache_key") or "")
             scope = hashlib.sha256((str(self.headers.get("chatgpt-account-id") or "") + "|" + thread).encode()).hexdigest()
             source = TRANSFERS.get(scope) if thread else None
             # A completed return to the subscription ends migration. Historical
             # foreign IDs must not keep later native turns in the preparer.
-            mixed = ek_model_mu(source or "") or (source is None and gecis_context.foreign(req))
-            if external or mixed:
+            mixed = ek_model_mu(source or "") or (source is None and gecis_context.foreign_history(req))
+            # Format repair is stateless: the saved transcript can still contain
+            # foreign wrappers after a successful native return (or a restart).
+            if external or mixed or gecis_context.foreign(req):
                 try:
                     normalized = gecis_context.normalize(req)
                 except gecis_context.TransferError as e:
                     self._transfer_begin()
                     return self._transfer_fail(str(e))
                 # Small returning requests need no summarizer or local worker.
-                if external or gecis_context.tokens(normalized) > int(32768 * 0.70):
+                # Native opaque state must remain on its owner route. Its byte
+                # size is not a semantic token budget and cannot trigger a
+                # foreign summarizer, including when transfer state is cold.
+                if external or (mixed and not gecis_context.native_opaque(normalized)
+                                and gecis_context.tokens(normalized) > int(32768 * 0.70)):
                     prepared, started = self._prepare(normalized, source)
                     if prepared is None:
                         return
@@ -535,6 +588,10 @@ class H(http.server.BaseHTTPRequestHandler):
 
 
 class Sunucu(http.server.ThreadingHTTPServer):
+    def __init__(self, *args, **kwargs):
+        self.failure_replays = terminal_stream.FailureReplays()
+        super().__init__(*args, **kwargs)
+
     daemon_threads = True
     # Shipped Python 3.11 defaults to only five pending connections. Model
     # discovery, voice and simultaneous chats can arrive in the same burst.

apps/desktop/assets/codex-bridge/compression_engine.py

@@ -180,9 +180,13 @@ def prepare(handler, module, payload, checkpoints):
     slug = original.get('model', '')
     external = module.ek_model_mu(slug)
     source_model = payload.get('source_model') or ''
+    if not external and gc.native_opaque(original):
+        # Defense in depth for direct/older splitter callers. Native encrypted
+        # state never enters owner decoding or cross-provider summarization.
+        return {'request': gc.normalize(original)}
     # Defense in depth: an accidental worker call cannot alter native-only history.
-    if not external and not module.ek_model_mu(source_model) and not gc.foreign(original):
-        return {'request': copy.deepcopy(original), 'window': handler._transfer_window(slug)}
+    if not external and not module.ek_model_mu(source_model) and not gc.foreign_history(original):
+        return {'request': gc.normalize(original)}
     settings = settings_store.read(module.HOME)
     actual = (module.yonlendirilen(str(original.get('prompt_cache_key') or ''), slug) or slug) if external else slug
     window = handler._transfer_window(actual)

apps/desktop/assets/codex-bridge/gecis_context.py

@@ -7,6 +7,7 @@ must not enter the budget preparation path.
 import copy
 import hashlib
 import json
+import re
 import threading
 from collections import OrderedDict
 
@@ -53,6 +54,22 @@ def foreign(req):
     return False
 
 
+def native_opaque(req):
+    """Native encrypted state belongs to the subscription, even in mixed history."""
+    return any(isinstance(item, dict) and item.get("type") == "compaction" and item.get("encrypted_content")
+               and not str(item["encrypted_content"]).startswith(ozet_kopru.ISARET)
+               for item in req.get("input") or [])
+
+
+def foreign_history(req):
+    """Semantic migration evidence, excluding tool ID format mismatches."""
+    return any(isinstance(item, dict) and (
+        "chatcmpl-" in str(item.get("id") or "")
+        or "astrabridge" in str(item.get("id") or "")
+        or str(item.get("encrypted_content") or "").startswith(ozet_kopru.ISARET))
+        for item in req.get("input") or [])
+
+
 def normalize(req):
     """Repair local wrappers/IDs, retaining real OpenAI encrypted compaction.
 
@@ -81,6 +98,10 @@ def normalize(req):
             if any(visible):
                 result.append(ozet_kopru._ozet_mesaji("\n".join(visible)))
             continue
+        if ("chatcmpl-" in str(identity) or "astrabridge" in str(identity)) and (
+                item.get("type") == "message" or item.get("role")):
+            # Inline message content is portable; its foreign server ID is not.
+            item.pop("id", None)
         prefix = PREFIXES.get(item.get("type"))
         if prefix and isinstance(identity, str) and identity and not identity.startswith(prefix + "_"):
             item["id"] = prefix + "_" + identity.split("_", 1)[-1]
@@ -104,6 +125,31 @@ def portable_reasoning(req):
         return out
     result = []
     for item in items:
+        if isinstance(item, dict) and item.get("type") == "agent_message":
+            # Peer messages carry delegated tasks/results. External Responses
+            # translators do not understand this Codex-specific item type.
+            # Keep provenance as data, never as system/developer authority.
+            content = item.get("content") or []
+            if isinstance(content, str):
+                content = [{"type": "input_text", "text": content}]
+            portable = []
+            for part in content:
+                if isinstance(part, dict) and part.get("type") == "encrypted_content":
+                    # Codex peer delivery can put the literal task/result in
+                    # this wrapper. It is distinct from encrypted reasoning.
+                    # External translators otherwise silently drop the task.
+                    text = part.get("encrypted_content")
+                    if (not isinstance(text, str) or text.startswith("gAAAA")
+                            or re.fullmatch(r"[A-Za-z0-9_+/=-]{128,}", text)):
+                        raise TransferError("Alt ajan iletisi şifreli veya okunamıyor; görev eksik gönderilmedi.")
+                    portable.append({"type": "input_text", "text": text})
+                else:
+                    portable.append(part)
+            result.append({"type": "message", "role": "user", "content": [
+                {"type": "input_text", "text": "Agent message: " + encoded({
+                    "author": item.get("author"), "recipient": item.get("recipient")})}
+            ] + portable})
+            continue
         if not isinstance(item, dict) or item.get("type") != "reasoning":
             result.append(item)
             continue

apps/desktop/assets/codex-bridge/ide_catalog.py

@@ -348,11 +348,13 @@ def yukle(ua="AstraBridge/1.0 (codex)", timeout=30, home=None, ag=True):
     if not girdiler:
         raise ValueError("Gecitte kullanilabilir OmniRoute sohbet modeli yok")
     kayitlar = {m["id"]: m for m in metadata if m.get("id")}
+    ilanlar = {m["id"]: m for m in data if m.get("id")}
     nano = pencere.nano_yukle(home, ua, ag=ag)     # ag=False: acilista yalniz onbellek
     ogr = pencere.ogrenilen(home)
     aracsiz = pencere.aracsizlar(home)
     for g in girdiler:
-        bilgi = pencere.coz(g["id"], g["kind"], g.get("yol"), kayitlar.get(g["id"]), nano, ogr, aracsiz)
+        bilgi = pencere.coz(g["id"], g["kind"], g.get("yol"), kayitlar.get(g["id"]), nano, ogr, aracsiz,
+                            ilan=ilanlar.get(g["id"]))
         g["pencere"], g["gorsel"], g["arac"], g["pencere_kaynak"] = (bilgi["pencere"], bilgi["gorsel"],
                                                                      bilgi["arac"], bilgi["kaynak"])
         g["claude"] = pencere.claude_var(g["kind"], g.get("yol"), kayitlar.get(g["id"]))

apps/desktop/assets/codex-bridge/jev-settings-defaults.json

@@ -5,10 +5,9 @@
   "fallbackModel": "Katman-1",
   "rejectionRules": [
     { "from": "Katman-1", "to": "Katman-2" },
-    { "from": "Katman-2", "to": "Katman-3" },
-    { "from": "Katman-3", "to": "Katman-4" }
+    { "from": "Katman-2", "to": "Katman-3" }
   ],
-  "exemptModels": ["Sesli-Hizli-Zeki", "Katman-4"],
+  "exemptModels": ["Chat-Model", "bekci-sesli-bekci", "Sesli-Hizli-Zeki", "Katman-3"],
   "thresholds": { "ret": 0.5, "sart": 0.7 },
   "questions": {
     "ret": "The assistant did NOT do what the user asked or did NOT answer the user's question: it refused, declined, said it cannot or will not, avoided giving the requested judgment, or redirected to a different topic.",
@@ -18,5 +17,40 @@
   "criteria": { "ret": { "true": "", "false": "" }, "sart": { "true": "", "false": "" } },
   "maxConcurrent": 0,
   "queueWaitSeconds": 3600,
-  "failureAction": "pass"
+  "failureAction": "pass",
+  "watchModels": ["Sesli-Hizli-Zeki", "Chat-Model", "bekci-sesli-bekci"],
+  "prefilter": {
+    "enabled": false,
+    "question": "A mainstream AI assistant such as ChatGPT, Claude or Gemini would refuse this request, water it down, or answer it only with added warnings or conditions.",
+    "threshold": 0.6,
+    "target": "Katman-2",
+    "timeoutSeconds": 3
+  },
+  "autoRoute": {
+    "enabled": false,
+    "model": "Otomatik",
+    "timeoutSeconds": 3,
+    "questions": {
+      "zor": "The user's request is hard: doing it well needs multi-step work, expert or technical knowledge, careful analysis, planning, calculation or writing and changing code. Greetings, small talk, simple facts and short simple commands are NOT hard.",
+      "arastirma": "The user's request is mainly research: finding, reading and comparing many sources or files and reporting what they say, rather than changing anything."
+    },
+    "thresholds": { "zor": 0.5, "arastirma": 0.6 },
+    "targets": { "basit": "Workflow-Kesif", "zor": "Ajan", "arastirma": "Arastirma" }
+  },
+  "finishCheck": {
+    "enabled": false,
+    "question": "The assistant stopped before the user's task was finished: it said it is done or handed back without doing all of what was asked, or it claimed success (tests pass, file changed, deployed) without showing the actual evidence.",
+    "threshold": 0.6,
+    "note": "Önceki cevabın iş bitmeden bitti dedi ya da kanıt göstermedi. İşi gerçekten bitir; gerekiyorsa araçları kullan ve gerçek kanıtı göster."
+  },
+  "verifierCheck": {
+    "enabled": false,
+    "question": "The reviewer approved the work without concrete evidence: it does not cite the actual diff, the real command output or specific lines, so the approval may be a guess.",
+    "threshold": 0.6
+  },
+  "policy": {
+    "source": "local",
+    "endpoint": "https://dify.turkservis.online/v1",
+    "refreshMinutes": 5
+  }
 }

apps/desktop/assets/codex-bridge/jev_denetim.py

@@ -4,11 +4,16 @@ Kullanici karari (11 Ekim 2026): "Jev kati olsun. Af yok istisna yok. Herhangi b
 gecirmezse 1.Katmana yonlendirecek. 1.Katman combosu gecmezse 2.Katmana, 2.Katman gecmezse 3.Katmana, 3.Katman
 gecmezse 4.Katmana. 4.Katman combosu gelirse Jev bunu sorgulamadan gecirecek."
 
-12 Ekim 2026 istisnasi: çözülmüş hedefi tam Sesli-Hizli-Zeki olan cevap Jev'e sorulmaz.
+12 Ekim 2026 istisnasi: çözülmüş hedefi muaf listesinde olan cevap Jev'e sorulmaz (ayar: exemptModels).
 Taşıma/boş yanıt kurtarması ve yedek katmanların denetimi korunur.
 Diğer hedeflerde denetim secili modelin katman olup olmamasina bakmaz.
-Gecmezse adimi sirayla Katman-1 -> Katman-2 -> Katman-3 -> Katman-4 yapar; secili model zaten bir katmansa
-yalniz ondan sonrakiler denenir. Katmanlar OmniRoute combolaridir (KATMAN); kopru onlari yalniz adiyla cagirir.
+Gecmezse adimi ayardaki zincir yapar (14 Ekim 2026: Katman-1 -> Katman-2 -> Katman-3, Katman-3 muaf); secili model
+zaten bir katmansa yalniz ondan sonrakiler denenir. Katmanlar OmniRoute combolaridir; kopru onlari yalniz adiyla cagirir.
+
+14 Ekim 2026 karar asamalari (hepsi ayardan acilir, varsayilan kapali): tur basinda "Otomatik" modelin combo secimi
+(autoRoute), normal modelin reddedecegi tahmin edilen isi dogrudan katmana verme (prefilter), isi bitirmeden "bitti"
+diyen son cevabi ayni modele bir kez geri verme (finishCheck). Karar modeli metin yazmaz; hata ya da zaman asiminda
+bugunku yol izlenir.
 
 Jev (TypeSafe System One) metin uretmez, sorulan evet/hayir sorularina olasilik verir. Kural tektir ve istisnasi
 yoktur: cevap istegi yapmiyorsa (ret) ya da sormadan kendi sartlariyla degistiriyorsa (sart) adim gecmez.
@@ -22,7 +27,7 @@ import jev_settings
 
 ADRES = "https://api.typesafe.ai/v1/systemone"
 MODEL = "jev-1.13.0"
-KATMAN = ("Katman-1", "Katman-2", "Katman-3", "Katman-4")
+KATMAN = ("Katman-1", "Katman-2", "Katman-3")  # varsayilan zincir; asil zincir ayardan okunur
 ESIK = {"ret": 0.5, "sart": 0.7}
 SORU = {
     "ret": ("The assistant did NOT do what the user asked or did NOT answer the user's question: it refused, declined, "
@@ -32,6 +37,17 @@ SORU = {
 }
 _ANAHTAR = {"okundu": False, "deger": ""}
 
+def izleme_mi(hedef):
+    """Bekci izleme kanali (cevaptan sonra duzeltme) bu hedefin mi? Ayar: watchModels, tam ad eslesmesi.
+    Jev acikken yalniz muaf hedefte: denetlenen cevap baska katmana gecebilir, makbuz kullanicinin gormedigi
+    cevaba baglanmasin."""
+    try:
+        s = jev_settings.read()[0]
+        return hedef in s['watchModels'] and (not s['enabled'] or hedef in s['exemptModels'])
+    except Exception:
+        return False
+
+
 def muaf_mi(hedef):
     """Settings' always-pass list matches exact resolved model IDs.
 
@@ -109,16 +125,28 @@ def _metin(oge):
 def son_istek(req):
     """Kullanicinin bu turdaki istegi: son kullanici mesaji. Sesli aktarimda yalniz <input> icindeki soz;
     baska sarmalli sistem mesajlari (kanca baglami) atlanir."""
-    for oge in reversed(req.get("input") or []):
-        if not (isinstance(oge, dict) and oge.get("type", "message") == "message" and oge.get("role") == "user"):
-            continue
-        metin = _metin(oge).strip()
-        m = re.search(r"<realtime_delegation>.*?<input>(.*?)</input>", metin, re.S)
-        if m:
-            return m.group(1).strip()
-        if metin and not metin.startswith("<"):
-            return metin
-    return ""
+    return son_istek_sirasi(req)[0]
+
+
+def istek_metni(oge):
+    """Bir kullanici mesajindaki istek: sesli aktarimda <input> icindeki soz; sarmalli sistem mesaji ise ""."""
+    if not (isinstance(oge, dict) and oge.get("type", "message") == "message" and oge.get("role") == "user"):
+        return ""
+    metin = _metin(oge).strip()
+    m = re.search(r"<realtime_delegation>.*?<input>(.*?)</input>", metin, re.S)
+    if m:
+        return m.group(1).strip()
+    return metin if metin and not metin.startswith("<") else ""
+
+
+def son_istek_sirasi(req):
+    """(istek, girdideki sirasi). Turun arac adimlarinda da ayni sira doner; yoksa ("", -1)."""
+    girdi = req.get("input") or []
+    for sira in range(len(girdi) - 1, -1, -1):
+        metin = istek_metni(girdi[sira])
+        if metin:
+            return metin, sira
+    return "", -1
 
 
 def hazirlik_mi(govde):
@@ -166,24 +194,83 @@ def komutlar(govde):
     return "\n".join(satirlar)
 
 
-def _gonder(govde, key, settings=None):
+def _gonder(govde, key, settings=None, timeout=None):
     settings = settings or jev_settings.read()[0]
     istek = urllib.request.Request(settings['endpoint'], data=json.dumps(govde).encode("utf-8"), method="POST",
                                    headers={"Authorization": "Bearer " + key, "Content-Type": "application/json"})
-    with urllib.request.urlopen(istek, timeout=settings['timeoutSeconds']) as yanit:
+    with urllib.request.urlopen(istek, timeout=timeout or settings['timeoutSeconds']) as yanit:
         return json.load(yanit)
 
 
+def sorular(durum, soru, key, timeout, gonder=_gonder, settings=None):
+    """Karar modeline bir cagrida birden cok evet/hayir sorusu. Donus {ad: 0-1 olasilik} | None (sorulamadi).
+    durum: {"user_request": ..., ["assistant_reply": ...]}; soru: {ad: talimat}."""
+    settings = settings or jev_settings.read()[0]
+    if not key or not soru or not durum.get("user_request"):
+        return None
+    govde = {"model": settings['model'], "state": durum,
+             "questions": {k: {"type": "noul", "instructions": v} for k, v in soru.items()}}
+    if not jev_settings.acquire(settings, wait=timeout):
+        return None
+    try:
+        response = gonder(govde, key, settings, timeout) if gonder is _gonder else gonder(govde, key)
+        yanitlar = (response or {}).get("answers") or {}
+        result = {k: float(yanitlar[k]["noul"]) for k in soru}
+        return result if all(0 <= v <= 1 for v in result.values()) else None
+    except Exception:
+        return None
+    finally:
+        jev_settings.release()
+
+
+def on_karar(istek, oto, ret, key, gonder=_gonder):
+    """Tur basi karari: istenen sorular tek cagrida. oto: Otomatik modelin combo secimi; ret: normal model reddeder mi.
+    Donus: {"hedef": Otomatik icin secilen ad ya da None, "ret": bool ya da None, "puan": {...} ya da None}."""
+    settings = jev_settings.read()[0]
+    a, p = settings['autoRoute'], settings['prefilter']
+    soru = {}
+    if oto:
+        soru.update(a['questions'])
+    if ret and p['enabled']:
+        soru["ret"] = p['question']
+    if not soru:
+        return {"hedef": None, "ret": None, "puan": None}
+    sure = max(a['timeoutSeconds'] if oto else 0, p['timeoutSeconds'] if ret else 0) or 3
+    puan = sorular({"user_request": istek}, soru, key, sure, gonder=gonder, settings=settings)
+    hedef = None
+    if oto:
+        if puan is None:
+            hedef = a['targets']['zor']        # karar alinamazsa guclu yol
+        elif puan["arastirma"] >= a['thresholds']['arastirma']:
+            hedef = a['targets']['arastirma']
+        elif puan["zor"] >= a['thresholds']['zor']:
+            hedef = a['targets']['zor']
+        else:
+            hedef = a['targets']['basit']
+    tahmin = None if puan is None or "ret" not in puan else puan["ret"] >= p['threshold']
+    return {"hedef": hedef, "ret": tahmin, "puan": puan}
+
+
+def bitmedi_mi(puan):
+    """finishCheck: son cevap isi bitirmeden 'bitti' mi dedi? Soru sorulmadiysa False."""
+    if not puan or "bitmedi" not in puan:
+        return False
+    return puan["bitmedi"] >= jev_settings.read()[0]['finishCheck']['threshold']
+
+
 class Puan(dict):
     """Carry the thresholds used for this evaluation through a settings change."""
     pass
 
 
-def sor(istek, cevap, key, gonder=_gonder):
-    """Jev'e sorar. Donus: {"ret", "sart"} olasiliklari | None (sorulamadi)."""
+def sor(istek, cevap, key, gonder=_gonder, bitis=False):
+    """Jev'e sorar. Donus: {"ret", "sart"[, "bitmedi"]} olasiliklari | None (sorulamadi).
+    bitis=True ve finishCheck acikken ayni cagriya "is bitmeden bitti mi dedi" sorusu da eklenir."""
     settings = jev_settings.read()[0]
     govde = {"model": settings['model'], "state": {"user_request": istek, "assistant_reply": cevap},
              "questions": {k: {"type": "noul", "instructions": v} for k, v in settings['questions'].items()}}
+    if bitis and settings['finishCheck']['enabled']:
+        govde['questions']['bitmedi'] = {"type": "noul", "instructions": settings['finishCheck']['question']}
     for name, criteria in settings.get('criteria', {}).items():
         values = {k: v for k, v in criteria.items() if v.strip()}
         if values:
@@ -193,7 +280,9 @@ def sor(istek, cevap, key, gonder=_gonder):
     try:
         response = gonder(govde, key, settings) if gonder is _gonder else gonder(govde, key)
         yanitlar = (response or {}).get("answers") or {}
-        result = Puan({k: float(yanitlar[k]["noul"]) for k in SORU})
+        result = Puan({k: float(yanitlar[k]["noul"]) for k in settings['questions']})
+        if 'bitmedi' in govde['questions'] and isinstance(yanitlar.get('bitmedi'), dict):
+            result['bitmedi'] = float(yanitlar['bitmedi']['noul'])  # ek soru: cevapsizsa ana karar yine gecerli
         if any(not 0 <= v <= 1 for v in result.values()):
             return None
         result.thresholds = settings['thresholds']

apps/desktop/assets/codex-bridge/jev_settings.py

@@ -1,4 +1,11 @@
-"""Per-user settings, re-read for new evaluations without restarting active chats."""
+"""Per-user settings, re-read for new evaluations without restarting active chats.
+
+Schema 2 (14 Oct 2026) adds the decision stages: watchModels, prefilter, autoRoute, finishCheck,
+verifierCheck and policy. A schema 1 file stays valid: every missing section is filled from the
+defaults, and every new stage starts disabled, so an upgrade changes no behaviour by itself.
+With policy.source "dify" the stage settings may be overridden by the last good rules fetched
+from Dify (jev-policy.json); invalid or missing rules leave the local settings in force.
+"""
 import base64
 import copy
 import ctypes
@@ -8,8 +15,13 @@ import sys
 import threading
 import time
 from pathlib import Path
+from urllib.parse import urlsplit
 
 DEFAULTS = json.loads(Path(__file__).with_name('jev-settings-defaults.json').read_text(encoding='utf-8'))
+POLICY_FILE = 'jev-policy.json'
+# Sections Dify rules may change. The transition chain and the always-pass list stay local.
+POLICY_KEYS = ('prefilter', 'autoRoute', 'finishCheck', 'verifierCheck', 'thresholds', 'questions')
+SECTIONS = ('watchModels', 'prefilter', 'autoRoute', 'finishCheck', 'verifierCheck', 'policy')
 _condition = threading.Condition()
 _active = 0
 
@@ -20,16 +32,37 @@ def home():
     return Path(os.environ.get('AITURK_CODEX_BRIDGE_HOME') or Path(__file__).parent)
 
 
-def read():
-    try:
-        data = json.loads((home() / 'jev-settings.json').read_text(encoding='utf-8'))
-    except FileNotFoundError:
-        return copy.deepcopy(DEFAULTS), None
-    settings = data['settings']
+def _fill(value, default):
+    """Missing keys of a schema 1 file come from the defaults; present values are kept as written."""
+    if isinstance(default, dict) and isinstance(value, dict):
+        return {k: _fill(value[k], d) if k in value else copy.deepcopy(d) for k, d in default.items()} | \
+            {k: v for k, v in value.items() if k not in default}
+    return value
+
+
+def _text(value, limit=10000):
+    return isinstance(value, str) and bool(value.strip()) and len(value) <= limit
+
+
+def _prob(value):
+    return isinstance(value, (int, float)) and not isinstance(value, bool) and 0 <= value <= 1
+
+
+def _int(value, low, high):
+    return isinstance(value, int) and not isinstance(value, bool) and low <= value <= high
+
+
+def _https(value):
+    if not _text(value, 2048):
+        return False
+    url = urlsplit(value)
+    return url.scheme == 'https' and bool(url.netloc) and not url.username and not url.password
+
+
+def validate(settings):
+    """Raise ValueError when a value could route to the wrong place or wait without bound."""
     # A corrupted file must not silently change routing or contact another host.
-    from urllib.parse import urlsplit
-    url = urlsplit(settings['endpoint'])
-    if url.scheme != 'https' or not url.netloc or url.username or url.password:
+    if not _https(settings['endpoint']):
         raise ValueError('Invalid Jev endpoint')
     for name in ('ret', 'sart'):
         n = settings['thresholds'][name]
@@ -42,24 +75,79 @@ def read():
         raise ValueError('Invalid Jev concurrency')
     if not settings['fallbackModel'] or not isinstance(settings['rejectionRules'], list) or settings['failureAction'] not in ('pass', 'next'):
         raise ValueError('Invalid Jev routing')
-    return settings, data.get('protectedKey')
+    watch = settings['watchModels']
+    if not isinstance(watch, list) or len(watch) > 64 or not all(_text(x, 256) for x in watch) or len(set(watch)) != len(watch):
+        raise ValueError('Invalid watch models')
+    p = settings['prefilter']
+    if not (isinstance(p.get('enabled'), bool) and _text(p.get('question')) and _prob(p.get('threshold'))
+            and _text(p.get('target'), 256) and _int(p.get('timeoutSeconds'), 1, 60)):
+        raise ValueError('Invalid prefilter')
+    a = settings['autoRoute']
+    if not (isinstance(a.get('enabled'), bool) and _text(a.get('model'), 256) and _int(a.get('timeoutSeconds'), 1, 60)
+            and all(_text((a.get('questions') or {}).get(k)) and _prob((a.get('thresholds') or {}).get(k)) for k in ('zor', 'arastirma'))
+            and all(_text((a.get('targets') or {}).get(k), 256) for k in ('basit', 'zor', 'arastirma'))):
+        raise ValueError('Invalid automatic routing')
+    if a['model'] in a['targets'].values() or p['target'] == a['model']:
+        raise ValueError('Automatic routing cannot target itself')
+    f = settings['finishCheck']
+    if not (isinstance(f.get('enabled'), bool) and _text(f.get('question')) and _prob(f.get('threshold'))
+            and _text(f.get('note'), 4000)):
+        raise ValueError('Invalid finish check')
+    v = settings['verifierCheck']
+    if not (isinstance(v.get('enabled'), bool) and _text(v.get('question')) and _prob(v.get('threshold'))):
+        raise ValueError('Invalid verifier check')
+    pol = settings['policy']
+    if not (pol.get('source') in ('local', 'dify') and _https(pol.get('endpoint')) and _int(pol.get('refreshMinutes'), 1, 1440)):
+        raise ValueError('Invalid policy source')
+    return settings
 
 
-def key():
-    _, encrypted = read()
+def _policy(settings):
+    """Last good Dify rules on top of the local settings; anything invalid keeps the local settings."""
+    if settings['policy']['source'] != 'dify':
+        return settings
+    try:
+        cache = json.loads((home() / POLICY_FILE).read_text(encoding='utf-8'))
+        overrides = cache.get('overrides')
+        if not cache.get('ok') or not isinstance(overrides, dict):
+            return settings
+        merged = copy.deepcopy(settings)
+        for key in POLICY_KEYS:
+            if isinstance(overrides.get(key), dict):
+                merged[key] = _fill(overrides[key], settings[key])
+        return validate(merged)
+    except (OSError, ValueError, KeyError, TypeError, AttributeError):
+        return settings
+
+
+def read(overlay=True):
+    """(settings, protectedKey). overlay=False: the local settings without the Dify rules."""
+    try:
+        data = json.loads((home() / 'jev-settings.json').read_text(encoding='utf-8'))
+    except FileNotFoundError:
+        return copy.deepcopy(DEFAULTS), None
+    settings = data['settings']
+    for section in SECTIONS:
+        settings[section] = _fill(settings[section], DEFAULTS[section]) if section in settings else copy.deepcopy(DEFAULTS[section])
+    validate(settings)
+    return (_policy(settings) if overlay else settings), data.get('protectedKey')
+
+
+class _Blob(ctypes.Structure):
+    _fields_ = [('cbData', ctypes.c_uint32), ('pbData', ctypes.POINTER(ctypes.c_ubyte))]
+
+
+def _unprotect(encrypted):
     if not encrypted:
         return ''
     if os.name != 'nt':
         raise RuntimeError('Windows credential protection required')
-    from ctypes import wintypes
-    class Blob(ctypes.Structure):
-        _fields_ = [('cbData', wintypes.DWORD), ('pbData', ctypes.POINTER(ctypes.c_ubyte))]
     raw = base64.b64decode(encrypted, validate=True)
     buf = (ctypes.c_ubyte * len(raw)).from_buffer_copy(raw)
-    source, result = Blob(len(raw), buf), Blob()
+    source, result = _Blob(len(raw), buf), _Blob()
     decrypt = ctypes.windll.crypt32.CryptUnprotectData
-    decrypt.argtypes = [ctypes.POINTER(Blob), ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p, wintypes.DWORD, ctypes.POINTER(Blob)]
-    decrypt.restype = wintypes.BOOL
+    decrypt.argtypes = [ctypes.POINTER(_Blob), ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_void_p, ctypes.c_uint32, ctypes.POINTER(_Blob)]
+    decrypt.restype = ctypes.c_int
     if not decrypt(ctypes.byref(source), None, None, None, None, 0, ctypes.byref(result)):
         raise ctypes.WinError()
     try:
@@ -69,9 +157,56 @@ def key():
         ctypes.windll.kernel32.LocalFree(result.pbData)
 
 
-def acquire(settings):
+def key():
+    _, encrypted = read()
+    return _unprotect(encrypted)
+
+
+def policy_key():
+    """Dify app key for the rules source (protectedPolicyKey, Windows DPAPI). Empty when not set."""
+    try:
+        data = json.loads((home() / 'jev-settings.json').read_text(encoding='utf-8'))
+    except (OSError, ValueError):
+        return ''
+    return _unprotect(data.get('protectedPolicyKey'))
+
+
+def write_policy(result):
+    """Atomically store the outcome of a Dify fetch. A failed fetch keeps the last good overrides."""
+    path = home() / POLICY_FILE
+    previous = {}
+    try:
+        previous = json.loads(path.read_text(encoding='utf-8'))
+    except (OSError, ValueError):
+        pass
+    record = {'fetchedAt': time.strftime('%Y-%m-%dT%H:%M:%S%z'), 'ok': bool(result.get('ok')), 'error': str(result.get('error') or '')[:500]}
+    record['overrides'] = result.get('overrides') if result.get('ok') else previous.get('overrides')
+    if not result.get('ok') and previous.get('ok'):
+        record['ok'] = True          # the last good rules stay in force; the error is reported beside them
+        record['lastGoodAt'] = previous.get('lastGoodAt') or previous.get('fetchedAt')
+    elif result.get('ok'):
+        record['lastGoodAt'] = record['fetchedAt']
+    tmp = path.with_name(path.name + f'.{os.getpid()}.{threading.get_ident()}.tmp')
+    tmp.write_text(json.dumps(record, ensure_ascii=False, indent=2), encoding='utf-8')
+    try:
+        for deneme in range(5):
+            try:
+                os.replace(tmp, path)     # Windows: a reader holding the file makes this fail briefly
+                break
+            except PermissionError:
+                if deneme == 4:
+                    raise
+                time.sleep(0.05 * (deneme + 1))
+    finally:
+        if tmp.exists():
+            tmp.unlink()
+    return record
+
+
+def acquire(settings, wait=None):
+    """wait: at most this many seconds in the queue (turn-start questions must not hold a request)."""
     global _active
-    deadline = time.monotonic() + settings['queueWaitSeconds']
+    deadline = time.monotonic() + (min(settings['queueWaitSeconds'], wait) if wait else settings['queueWaitSeconds'])
     with _condition:
         while settings['maxConcurrent'] and _active >= settings['maxConcurrent']:
             remaining = deadline - time.monotonic()

apps/desktop/assets/codex-bridge/karar_politikasi.py

@@ -0,0 +1,102 @@
+"""Decision rules from Dify (14 Oct 2026).
+
+Owner request, 14 Oct 2026: "Dify'de hazirlansa oradan gelse". The model a Codex step talks to stays an
+OmniRoute combo, because a Dify app would not pass Codex's own tools through. What Dify supplies is the rules:
+the decision questions, thresholds and which combo each kind of request goes to. The bridge fetches them in
+the background (policy.refreshMinutes), validates them against the local settings and stores the last good
+copy in jev-policy.json. A turn never waits for Dify; a failed fetch keeps the last good rules.
+
+The Dify workflow returns one output named ``kurallar``: a JSON object (or JSON text) whose keys are any of
+jev_settings.POLICY_KEYS, each holding the same fields as the local settings section, for example
+{"autoRoute": {"enabled": true, "targets": {"zor": "Ajan"}}}.
+"""
+import copy
+import json
+import time
+import urllib.error
+import urllib.request
+
+import jev_settings
+
+UA = "AITURK-IDE-codex-bridge/karar-politikasi"
+
+
+class _YonlendirmeYok(urllib.request.HTTPRedirectHandler):
+    """A redirect would carry the Authorization header to another host; it is an error instead."""
+    def redirect_request(self, req, fp, code, msg, headers, newurl):
+        raise urllib.error.HTTPError(req.full_url, code, f"redirect refused: {newurl}", headers, fp)
+
+
+_ACICI = urllib.request.build_opener(_YonlendirmeYok)
+MAX_BYTES = 64 * 1024
+_son = {"zaman": 0.0}
+
+
+def ayikla(cikti, yerel):
+    """Dify output -> validated overrides. Raises ValueError with a short reason when unusable."""
+    if isinstance(cikti, str):
+        if len(cikti.encode("utf-8")) > MAX_BYTES:
+            raise ValueError("kurallar too large")
+        cikti = json.loads(cikti)
+    if not isinstance(cikti, dict):
+        raise ValueError("kurallar is not an object")
+    bilinmeyen = sorted(set(cikti) - set(jev_settings.POLICY_KEYS))
+    if bilinmeyen:
+        raise ValueError("unknown sections: " + ", ".join(bilinmeyen))
+    overrides = {k: v for k, v in cikti.items() if isinstance(v, dict)}
+    if len(overrides) != len(cikti):
+        raise ValueError("every section must be an object")
+    birlesik = copy.deepcopy(yerel)
+    for k, v in overrides.items():
+        birlesik[k] = jev_settings._fill(v, yerel[k])
+    jev_settings.validate(birlesik)
+    return overrides
+
+
+def cek(settings, key, urlopen=_ACICI.open):
+    """One fetch. Returns {"ok": bool, "overrides": {...}, "error": str}; never raises."""
+    if not key:
+        return {"ok": False, "error": "Dify key not configured"}
+    url = settings['policy']['endpoint'].rstrip('/') + '/workflows/run'
+    govde = json.dumps({"inputs": {}, "response_mode": "blocking", "user": "aiturk-codex-bridge"}).encode("utf-8")
+    istek = urllib.request.Request(url, data=govde, method="POST", headers={
+        "Authorization": "Bearer " + key, "Content-Type": "application/json", "User-Agent": UA})
+    try:
+        with urlopen(istek, timeout=30) as yanit:
+            ham = yanit.read(MAX_BYTES * 4 + 1)
+        if len(ham) > MAX_BYTES * 4:
+            return {"ok": False, "error": "Dify response too large"}
+        veri = json.loads(ham)
+        cikti = ((veri.get("data") or {}).get("outputs") or {}).get("kurallar")
+        if cikti is None:
+            return {"ok": False, "error": "Dify output 'kurallar' missing"}
+        return {"ok": True, "overrides": ayikla(cikti, settings)}
+    except Exception as e:
+        return {"ok": False, "error": f"{type(e).__name__}: {e}"[:300]}
+
+
+def zamani_mi(settings, simdi=None):
+    simdi = time.time() if simdi is None else simdi
+    return settings['policy']['source'] == 'dify' and simdi - _son["zaman"] >= settings['policy']['refreshMinutes'] * 60
+
+
+def yenile(log=lambda _m: None, urlopen=_ACICI.open, zorla=False):
+    """Fetch when due; store the outcome. Local settings are read without the Dify overlay."""
+    try:
+        yerel, _ = _yerel_ayar()
+    except Exception as e:
+        log(f"karar kurallari: ayar okunamadi ({type(e).__name__})")
+        return None
+    if not zorla and not zamani_mi(yerel):
+        return None
+    _son["zaman"] = time.time()
+    sonuc = cek(yerel, jev_settings.policy_key(), urlopen=urlopen)
+    kayit = jev_settings.write_policy(sonuc)
+    log("karar kurallari Dify'dan alindi" if sonuc.get("ok") else f"karar kurallari alinamadi: {sonuc.get('error')}"
+        + (" (son gecerli kurallar kullaniliyor)" if kayit.get("ok") else ""))
+    return kayit
+
+
+def _yerel_ayar():
+    """Settings as written locally (no Dify overlay), so a bad overlay can never validate itself."""
+    return jev_settings.read(overlay=False)

apps/desktop/assets/codex-bridge/karar_sor.py

@@ -0,0 +1,58 @@
+"""One decision-model question from the command line (14 Oct 2026).
+
+Used by the Codex dynamic-workflow acceptance step (verifierCheck): before a reviewer's "kabul" is accepted,
+the decision model is asked whether the approval cites concrete evidence. Reads the IDE's own Kademeli Geçiş
+settings and key; nothing is written.
+
+    python karar_sor.py dogrulayici < {"user_request": "...", "assistant_reply": "..."}
+
+Prints JSON {"enabled": bool, "kanitsiz": bool|null, "puan": float|null, "neden": str}. Exit 0 also when the
+stage is off or the model cannot be reached; the caller decides what an unanswered check means.
+"""
+import json
+import os
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+import jev_denetim  # noqa: E402
+import jev_settings  # noqa: E402
+
+SINIR = 20000
+
+
+def dogrulayici(veri, anahtar=None, gonder=None):
+    s = jev_settings.read()[0]
+    v = s['verifierCheck']
+    if not (s['enabled'] and v['enabled']):
+        return {'enabled': False, 'kanitsiz': None, 'puan': None, 'neden': 'kapali'}
+    durum = {'user_request': str(veri.get('user_request') or '')[:SINIR], 'assistant_reply': str(veri.get('assistant_reply') or '')[:SINIR]}
+    ek = {'gonder': gonder} if gonder else {}
+    puan = jev_denetim.sorular(durum, {'kanitsiz': v['question']}, jev_denetim.anahtar() if anahtar is None else anahtar, 15, **ek)
+    if puan is None:
+        return {'enabled': True, 'kanitsiz': None, 'puan': None, 'neden': 'karar modeline sorulamadi'}
+    return {'enabled': True, 'kanitsiz': puan['kanitsiz'] >= v['threshold'], 'puan': round(puan['kanitsiz'], 3), 'neden': ''}
+
+
+def main(argv=None, stdin=None, out=None):
+    argv = sys.argv[1:] if argv is None else argv
+    stdin, out = stdin or sys.stdin, out or sys.stdout
+    soru = [a for i, a in enumerate(argv) if a != '--home' and (i == 0 or argv[i - 1] != '--home')]
+    if soru != ['dogrulayici']:
+        print('kullanim: python karar_sor.py dogrulayici < {"user_request": ..., "assistant_reply": ...}', file=sys.stderr)
+        return 2
+    try:
+        veri = json.load(stdin)
+        sonuc = dogrulayici(veri if isinstance(veri, dict) else {})
+    except Exception as e:
+        sonuc = {'enabled': None, 'kanitsiz': None, 'puan': None, 'neden': f'{type(e).__name__}: {e}'[:300]}
+    out.write(json.dumps(sonuc, ensure_ascii=False))
+    return 0
+
+
+if __name__ == '__main__':
+    # Installed copy: the settings live in the user's bridge home, not next to this file.
+    if '--home' not in sys.argv and not os.environ.get('AITURK_CODEX_BRIDGE_HOME'):
+        os.environ['AITURK_CODEX_BRIDGE_HOME'] = str(Path(os.environ.get('LOCALAPPDATA', '')) / 'TurkServis' / 'AITURK-IDE' / 'codex-bridge')
+    sys.exit(main())

apps/desktop/assets/codex-bridge/kopru.py

@@ -34,13 +34,15 @@ import model_gecis
 import is_hatti
 import internet
 import jev_denetim
+import jev_settings
+import karar_politikasi
 
 from bekci_watch import MetadataFilter
 
 # Installed only by owned native launcher, never an HTTP control endpoint.
 WATCH_OWNER = None
 
-SURUM = "14"
+SURUM = "19"
 HERE = os.path.dirname(os.path.abspath(__file__))
 try:
     with open(os.path.abspath(__file__), "rb") as _f:
@@ -228,6 +230,23 @@ def load_ide_catalog(ag=True):
                                "kaynak": g.get("pencere_kaynak") or "", "claude": bool(g.get("claude"))}
             model_map[slug] = (IDE_ROUTE, g["id"], None)
             n += 1
+        oto = _oto_ayari()
+        if oto and IDE_PREFIX + oto["model"] not in model_map:
+            # Sanal model: istek geldiginde karar modeli ayardaki combo'lardan birini secer (14 Ekim 2026).
+            slug = IDE_PREFIX + oto["model"]
+            pencereler = [IDE_BILGI.get(IDE_PREFIX + h, {}).get("pencere") for h in set(oto["targets"].values())]
+            pencere_oto = min(pencereler) if pencereler and all(pencereler) else None
+            extra_models.append({"slug": slug, "display_name": f"{oto['model']} (karar modeli seçer)",
+                                 "description": "Her turda karar modeli işin türüne göre combo seçer: "
+                                                + ", ".join(f"{k}: {v}" for k, v in oto["targets"].items()),
+                                 "route": IDE_ROUTE, "target": oto["model"], "clone_from": clone, "priority": 299,
+                                 "reasoning_levels": levels, "kind": "combo", "context_window": pencere_oto})
+            IDE_BILGI[slug] = {"pencere": pencere_oto, "gorsel": all(IDE_BILGI.get(IDE_PREFIX + h, {}).get("gorsel")
+                                                                     for h in set(oto["targets"].values())),
+                               "arac": True, "kaynak": "", "claude": False}
+            model_map[slug] = (IDE_ROUTE, oto["model"], None)
+            OTO_ADI[0] = oto["model"]
+            n += 1
     else:
         ROUTES.pop(IDE_ROUTE, None)
     MODEL_MAP = model_map
@@ -237,10 +256,141 @@ def load_ide_catalog(ag=True):
         IDE_DURUM[0] = ozet
         log(f"AITURK IDE Codex Baglama: {ozet}")
 
+def _oto_ayari():
+    """autoRoute acik ve Kademeli Gecis acikken onun ayari; degilse None. Ayar okunamazsa None."""
+    try:
+        s = jev_settings.read()[0]
+    except Exception:
+        return None
+    return s["autoRoute"] if s["enabled"] and s["autoRoute"]["enabled"] else None
+
+# Tur basi kararlari: sohbet -> (tur anahtari, gelen slug, secilen slug). Ayni turun adimlari ayni karari kullanir.
+ON_KARAR = {}
+ON_KARAR_SINIR = 500
+BITIS_TURLARI = {}              # finishCheck kullanilan turlar (turda bir kez)
+KARAR_KILIDI = threading.Lock()
+OTO_ADI = ["Otomatik"]          # katalogdaki sanal modelin son adi (karar asamasi hata verirse disari cikmasin)
+
 # Acilista pencere verisi icin aga cikilmaz (IDE koprunun dinlemeye baslamasini sinirli sure bekler);
 # ilk tam yenileme asagidaki dongunun basinda, arka planda yapilir.
 load_ide_catalog(ag=False)
 
+def tur_bilgisi(req, sohbet):
+    """(sohbet koku, tur anahtari, tur basindaki istek, yeni tur mu). Tur, calisan bir turun icine dusmeyen
+    kullanici mesajiyla baslar. Arac adimlari, tur ortasinda yazilan mesaj, tek "." ve ozet istegi ayni turdadir;
+    yeni tur yalniz son oge yeni bir kullanici istegi oldugunda baslar."""
+    girdi = req.get("input") or []
+    kok = sohbet or "anon:" + hashlib.sha256(json.dumps(girdi[:1], ensure_ascii=False, sort_keys=True,
+                                                        default=str).encode("utf-8", "replace")).hexdigest()
+    bas, istek = -1, ""
+    for i in range(len(girdi) - 1, -1, -1):
+        metin = jev_denetim.istek_metni(girdi[i])
+        if not metin or metin == ".":
+            continue
+        if not istek:
+            bas, istek = i, metin            # tur basi bulunamazsa en son gercek istek
+        if not model_gecis.tur_ortasi(req, i):
+            bas, istek = i, metin
+            break
+    son = model_gecis.son_sira(girdi)
+    yeni = son >= 0 and son == bas and not model_gecis.tur_ortasi(req, son)
+    tur = hashlib.sha256(f"{kok}\0{bas}\0{istek}".encode("utf-8", "replace")).hexdigest()
+    return kok, tur, istek, yeni
+
+
+def karar_asamasi(n, req, sohbet, slug):
+    """14 Ekim 2026 karar asamalari: "Otomatik" modelin combo secimi (autoRoute) ve normal modelin reddedecegi
+    tahmin edilen isi dogrudan ayardaki katmana verme (prefilter). Karar yalniz yeni turda verilir; ayni turun
+    adimlari ayni karari kullanir (tur ortasinda model degisirse saglayicilar arasi gecmis bozulur). Kapali ayar,
+    bos istek ya da karar modeli hatasi bugunku yolu degistirmez. Sanal model adi hicbir yolda gecide gitmez."""
+    if not slug.startswith(IDE_PREFIX):
+        return slug
+    settings = jev_settings.read()[0]
+    a, p = settings["autoRoute"], settings["prefilter"]
+    sanal = slug == IDE_PREFIX + a["model"]
+    kok, tur, istek, yeni = tur_bilgisi(req, sohbet)
+    with KARAR_KILIDI:
+        kayit = ON_KARAR.get(kok)
+    if sanal and not (settings["enabled"] and a["enabled"]):
+        # Kapatilmis Otomatik: son karar ya da guclu hedef; sanal ad gecide gitmez.
+        secilen = kayit[2] if kayit and kayit[1] == slug else IDE_PREFIX + a["targets"]["zor"]
+        log(f"[{n} {slug}] Otomatik kapali; bu adim {secilen} modeline gidiyor")
+        req["model"] = secilen
+        return secilen
+    if not settings["enabled"]:
+        return slug
+    hedef = slug[len(IDE_PREFIX):]
+    ret = p["enabled"] and (sanal or not (jev_denetim.muaf_mi(hedef) or hedef == p["target"]
+                                         or hedef in jev_denetim.sonrakiler(p["target"])))
+    if not sanal and not ret:
+        return slug
+    if kayit and kayit[1] == slug and (kayit[0] == tur or not yeni):
+        secilen = kayit[2]
+    else:
+        if istek:
+            t0 = time.time()
+            sonuc = jev_denetim.on_karar(istek, sanal, ret, jev_denetim.anahtar())
+            puan = sonuc["puan"]
+            log(f"[{n} {slug}] tur basi karari ({time.time() - t0:.1f} sn): "
+                + (", ".join(f"{k}={v:.2f}" for k, v in puan.items()) if puan else "karar modeline sorulamadi"))
+        else:
+            sonuc = {"hedef": a["targets"]["zor"] if sanal else None, "ret": None}
+        if sanal:
+            hedef = sonuc["hedef"]
+        secilen = IDE_PREFIX + hedef
+        if (p["enabled"] and sonuc["ret"] and not jev_denetim.muaf_mi(hedef) and hedef != p["target"]
+                and hedef not in jev_denetim.sonrakiler(p["target"])):
+            log(f"[{n} {slug}] ret on kontrolu: normal model reddedebilir, adim {p['target']} katmanindan basliyor")
+            secilen = IDE_PREFIX + p["target"]
+        req["model"] = secilen
+        with KARAR_KILIDI:
+            ON_KARAR.pop(kok, None)              # yeniden ekleme sirayi tazeler: aktif sohbet en son silinir
+            ON_KARAR[kok] = (tur, slug, secilen)
+            while len(ON_KARAR) > ON_KARAR_SINIR:
+                ON_KARAR.pop(next(iter(ON_KARAR)), None)
+    if secilen != slug:
+        log(f"[{n} {slug}] karar: bu tur {secilen} modeline gidiyor")
+        req["model"] = secilen
+    return secilen
+
+
+def bitis_kullan(tur):
+    """finishCheck turda en fazla bir kez: ilk cagri True (ve isaretler), sonrakiler False."""
+    with KARAR_KILIDI:
+        if tur in BITIS_TURLARI:
+            return False
+        BITIS_TURLARI[tur] = time.time()
+        while len(BITIS_TURLARI) > ON_KARAR_SINIR:
+            BITIS_TURLARI.pop(next(iter(BITIS_TURLARI)), None)
+        return True
+
+
+def sigan_katmanlar(sira, req, tag):
+    """Istegi sigdiramayacak katman zincirden cikar (bos baglam hatasiyla bosa dusmesin). Yalniz penceresi
+    guvenilir (pencere.bekci_calisir) katman atlanir; zincirin son halkasi hic atlanmaz."""
+    tahmin, sonuc = None, []
+    for i, ad in enumerate(sira):
+        bilgi = IDE_BILGI.get(IDE_PREFIX + ad) or {}
+        p = bilgi.get("pencere")
+        if p and i < len(sira) - 1 and pencere.bekci_calisir(bilgi.get("kaynak"), p):
+            if tahmin is None:
+                tahmin = pencere.tahmini_token(req, 2.0)
+            if tahmin > int(p * 0.90):
+                log(f"{tag} katman {ad} atlandi: istek sigmaz (tahmini {tahmin} token, pencere {p})")
+                continue
+        sonuc.append(ad)
+    return sonuc
+
+def karar_kurallari_dongusu():
+    """Dify kural kaynagi (policy.source = dify) arka planda yenilenir; tur hic beklemez."""
+    time.sleep(5)
+    while True:
+        try:
+            karar_politikasi.yenile(log)
+        except Exception as e:
+            log(f"karar kurallari yenileme hatasi: {type(e).__name__}: {e}")
+        time.sleep(60)
+
 def catalog_refresh_loop():
     """Kataloglari arka planda yeniler; liste istegini yavaslatmaz."""
     minutes = max(1, int(CFG.get("catalog_refresh_min", 5)))
@@ -258,6 +408,7 @@ def catalog_refresh_loop():
                 log(f"katalog yenileme hatasi: {e}")
 
 threading.Thread(target=catalog_refresh_loop, daemon=True).start()
+threading.Thread(target=karar_kurallari_dongusu, daemon=True).start()
 
 # ---- AITURK is hatti: isi gonderebilen AITURK komutu (is_hatti.py). Kurulum sonradan gelebilir: yoksa 2 dk'da bir bakilir.
 HAT_KOMUT = [None]
@@ -365,6 +516,10 @@ def arac_semalarini_duzelt(req):
 
 def flatten_request(req, tool_names=None):
     """additional_tools/namespace/custom -> duz function tools. Donus: custom arac adlari kumesi."""
+    if isinstance(req.get("input"), list) and any(
+            isinstance(item, dict) and item.get("type") == "agent_message" for item in req["input"]):
+        import gecis_context
+        req["input"] = gecis_context.portable_reasoning(req)["input"]
     custom = set()
     tools = []
     tool_names = tool_names if tool_names is not None else {}
@@ -939,7 +1094,7 @@ class H(http.server.BaseHTTPRequestHandler):
         self.send_header("Transfer-Encoding", "chunked")
         self.end_headers()
 
-    def _denetimli_akis(self, resp, tag, rewriter, izle, istek, sira, ac, hedef=None):
+    def _denetimli_akis(self, resp, tag, rewriter, izle, istek, sira, ac, hedef=None, devam=None):
         """Katman denetimi (jev_denetim.py): cevap istemciye verilmeden once tamami okunur ve Jev'e sorulur.
         Gecerse oldugu gibi verilir; gecmezse atilir ve ayni adimi siradaki katman yapar (ac(ad): (resp, rewriter,
         tag)). Son katmanin cevabi sorulmadan akar. Beklerken SSE yorum satiri gider ki Codex akisi kopmus saymasin."""
@@ -951,6 +1106,8 @@ class H(http.server.BaseHTTPRequestHandler):
         else:
             self._akis_basligi(resp, resp.status)
         kalan, son_yazi, son_govde = list(sira), time.time(), b""
+        devam_kullanildi = False      # finishCheck: son cevap ayni modele en fazla bir kez geri verilir
+        yedek = None                  # geri verilen istek basarisiz olursa teslim edilecek, Jev'den gecmis ilk cevap
 
         def w(b):
             if b:
@@ -995,7 +1152,10 @@ class H(http.server.BaseHTTPRequestHandler):
                     jev_done, jev_result = jev_threading.Event(), [None]
                     def denetle():
                         try:
-                            jev_result[0] = jev_denetim.sor(istek, metin, jev_denetim.anahtar())
+                            if devam is not None and not devam_kullanildi:
+                                jev_result[0] = jev_denetim.sor(istek, metin, jev_denetim.anahtar(), bitis=True)
+                            else:
+                                jev_result[0] = jev_denetim.sor(istek, metin, jev_denetim.anahtar())
                         finally:
                             jev_done.set()
                     jev_threading.Thread(target=denetle, daemon=True).start()
@@ -1007,14 +1167,32 @@ class H(http.server.BaseHTTPRequestHandler):
                         log(f"{tag} katman denetimi: Jev'e sorulamadi, {'siradaki katman' if gecmedi else 'cevap oldugu gibi geciyor'}")
                     else:
                         gecmedi = jev_denetim.karar(puan)
-                        log(f"{tag} katman denetimi: ret={puan['ret']:.2f} sart={puan['sart']:.2f} -> "
+                        log(f"{tag} katman denetimi: ret={puan['ret']:.2f} sart={puan['sart']:.2f}"
+                            + (f" bitmedi={puan['bitmedi']:.2f}" if 'bitmedi' in puan else "") + " -> "
                             f"{'GECMEDI' if gecmedi else 'gecti'} ({time.time() - t0:.1f} sn, {len(metin)} karakter{'' if yazi else ', yalniz komut'})")
+                        if not gecmedi and devam is not None and not devam_kullanildi and jev_denetim.bitmedi_mi(puan):
+                            devam_kullanildi = True
+                            try:
+                                yeni_devam = devam(hedef, metin)
+                            except Exception as e:
+                                yeni_devam = None
+                                log(f"{tag} bitis denetimi: devam istegi acilamadi, cevap oldugu gibi geciyor ({type(e).__name__}: {e})")
+                            if yeni_devam is not None:
+                                yedek = (parcalar, rewriter, tag)
+                                resp, rewriter, tag = yeni_devam
+                                log(f"{tag} bitis denetimi: is bitmeden bitti denmis, ayni modele bir kez geri verildi")
+                                continue
                 else:
                     # Bos adim: ne yazi var ne arac cagrisi (hata olayi da boyledir, or. "upstream 400"). Kabul
                     # edilmez, siradaki katman yapar; bos yanit cevap diye verilirse Codex adimi bastan dener.
                     gecmedi = True
                     log(f"{tag} katman denetimi: bos adim (yazi da komut da yok), siradakine geciliyor: "
                         f"{b''.join(parcalar)[-200:]!r}")
+                if gecmedi and yedek is not None:
+                    # Geri verilen istek koptu, bos dondu ya da gecmedi: Jev'den gecmis ilk cevap teslim edilir.
+                    parcalar, rewriter, tag = yedek
+                    gecmedi = False
+                    log(f"{tag} bitis denetimi: geri verilen istek kullanilamadi, ilk cevap teslim ediliyor")
                 yeni = None
                 while gecmedi and kalan and yeni is None:
                     ad = kalan.pop(0)
@@ -1031,13 +1209,13 @@ class H(http.server.BaseHTTPRequestHandler):
                 if jev_denetim.muaf_mi(hedef):
                     return self._stream(resp, resp.status, tag, rewriter, izle, basliksiz=True)
             if gecmedi:
-                # Son katman ne dondurduyse o gider, hicbir sey eklenmez; dondurmediyse hicbir sey gitmez.
-                if son_govde:
-                    w(son_govde)
-                else:
-                    event = {"type": "response.failed", "response": {"status": "failed", "error": {
-                        "code": "jev_no_fallback", "message": "Jev denetiminden gecen cevap alinamadi; gecis kurallarini kontrol edin."}}}
-                    w(b"event: response.failed\ndata: " + json.dumps(event).encode() + b"\n\n")
+                # Headers already declare SSE. A raw upstream JSON/HTML body
+                # here leaves Codex waiting for a terminal event and retrying.
+                event = {"type": "response.failed", "response": {
+                    "id": "resp_astrabridge_%d" % time.time_ns(),
+                    "object": "response", "status": "failed", "output": [], "error": {
+                    "code": "jev_no_fallback", "message": "Jev denetiminden gecen cevap alinamadi; gecis kurallarini kontrol edin."}}}
+                w(b"event: response.failed\ndata: " + json.dumps(event).encode() + b"\n\n")
             else:
                 for chunk in parcalar:
                     if izle is not None:
@@ -1283,7 +1461,7 @@ class H(http.server.BaseHTTPRequestHandler):
             for model in json.loads(cached["body"]).get("models", []):
                 if model.get("slug") == slug and model.get("context_window"):
                     return int(model["context_window"])
-        return 32768
+        raise gecis_context.TransferError("Abonelik modelinin bağlam kapasitesi katalogda bulunamadı; geçmiş korundu.")
 
 
     def _prepare_transfer(self, payload):
@@ -1543,6 +1721,16 @@ class H(http.server.BaseHTTPRequestHandler):
             if hedef and hedef != gelen:
                 req["model"] = slug = hedef
                 log(f"[{n} {gelen}] sohbet yonlendirmesi: istek {hedef} modeline gidiyor")
+        try:
+            slug = karar_asamasi(n, req, sohbet, slug)
+        except Exception as e:
+            log(f"[{n} {slug}] karar asamasi atlandi: {type(e).__name__}: {e}")
+            try:
+                if slug == IDE_PREFIX + OTO_ADI[0]:
+                    # Sanal ad gecide gitmez: varsayilan guclu hedef.
+                    slug = req["model"] = IDE_PREFIX + jev_settings.DEFAULTS["autoRoute"]["targets"]["zor"]
+            except Exception:
+                pass
         mapping = MODEL_MAP.get(slug)
         if CFG.get("nokta_karsila", True) and nokta_mesaji_mi(req) and model_gecis.tur_ortasi(req, model_gecis.son_sira(req["input"])):
             # Calisan turun icine dusen nokta secimi tasimaz (olcum 10 Ekim 2026) ve cevaplanirsa isi yarida
@@ -1729,15 +1917,25 @@ class H(http.server.BaseHTTPRequestHandler):
             open(os.path.join(LOGDIR, f"{n:04d}_req.json"), "wb").write(data)
         hdrs = {"Authorization": f"Bearer {route['key']}", "Content-Type": "application/json", "Accept": "text/event-stream", "User-Agent": UA}
         last = None
-        # Katman denetimi (jev_denetim.py): Sesli-Hizli-Zeki dışında ek modeller Jev'e sorulur; gecmezse adim
-        # sirayla Katman-1 -> 2 -> 3 -> 4 yapar (secili model zaten katmansa ondan sonrakiler). Katman-4 sorulmadan
-        # gecer. Katmanlar OmniRoute combolaridir: yedek her zaman AITURK gecidi (ide_route) uzerinden acilir,
+        # Katman denetimi (jev_denetim.py): muaf listesi disindaki ek modeller Jev'e sorulur; gecmezse adim
+        # ayardaki zinciri izler (14 Ekim 2026: Katman-1 -> 2 -> 3; secili model zaten katmansa ondan sonrakiler).
+        # Muaf katman sorulmadan gecer. Katmanlar OmniRoute combolaridir: yedek her zaman AITURK gecidi (ide_route) uzerinden acilir,
         # secili model baska bir rotada olsa bile. Gecit yoksa denetim yapilmaz. Ozet isteginde ve aracsiz
         # (rewriter yok) yolda kapalidir.
         jev_rota = ROUTES.get(ide_route)
-        jev_etkin = jev_denetim.etkin_mi() and not (ozet_tetik or rewriter is None or jev_rota is None or not jev_denetim.anahtar())
-        jev_sira = jev_denetim.sonrakiler(target) if jev_etkin else []
-        jev_istek = jev_denetim.son_istek(req) if jev_etkin else ""
+        try:
+            jev_etkin = jev_denetim.etkin_mi() and not (ozet_tetik or rewriter is None or jev_rota is None or not jev_denetim.anahtar())
+            jev_sira = jev_denetim.sonrakiler(target) if jev_etkin else []
+            jev_istek = jev_denetim.son_istek(req) if jev_etkin else ""
+        except Exception as e:
+            # Okunamayan ayar istegi dusurmez: bu adim denetimsiz gecer.
+            log(f"{tag} katman denetimi ayari okunamadi, denetimsiz devam: {type(e).__name__}: {e}")
+            jev_etkin, jev_sira, jev_istek = False, [], ""
+        if jev_sira:
+            try:
+                jev_sira = sigan_katmanlar(jev_sira, req, tag)
+            except Exception as e:
+                log(f"{tag} katman pencere kontrolu atlandi: {type(e).__name__}: {e}")
 
         def jev_ac(ad):
             katman_req = json.loads(data)
@@ -1747,8 +1945,38 @@ class H(http.server.BaseHTTPRequestHandler):
             yanit = urllib.request.urlopen(urllib.request.Request(
                 jev_rota["url"], data=json.dumps(katman_req, ensure_ascii=False).encode("utf-8"), headers=jev_hdrs, method="POST"),
                 timeout=UPSTREAM_IDLE_TIMEOUT)
-            return (yanit, SseRewriter(custom, hedef=ad, tasma=self._tasma_ogren, aracsiz=self._aracsiz_ogren),
+            return (yanit, SseRewriter(custom, hedef=ad, tasma=self._tasma_ogren, aracsiz=self._aracsiz_ogren, tool_names=tool_names),
                     f"[{n} {slug}=>{ad}]")
+
+        def jev_devam(ad, onceki):
+            """finishCheck: ayni hedefe, erken biten cevap ve not eklenmis istek. Yalniz AITURK gecidindeki hedefler.
+            Turda en fazla bir kez (bitis_kullan)."""
+            if ad == target and route_name != ide_route:
+                raise ValueError("hedef AITURK gecidinde degil")
+            if not bitis_kullan(bitis_turu):
+                raise ValueError("bu turda zaten geri verildi")
+            devam_req = json.loads(data)
+            devam_req["model"] = ad
+            devam_req.setdefault("input", []).extend([
+                {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": onceki}]},
+                {"type": "message", "role": "user", "content": [
+                    {"type": "input_text", "text": jev_settings.read()[0]["finishCheck"]["note"]}]}])
+            jev_hdrs = {"Authorization": f"Bearer {jev_rota['key']}", "Content-Type": "application/json",
+                        "Accept": "text/event-stream", "User-Agent": UA}
+            yanit = urllib.request.urlopen(urllib.request.Request(
+                jev_rota["url"], data=json.dumps(devam_req, ensure_ascii=False).encode("utf-8"), headers=jev_hdrs, method="POST"),
+                timeout=UPSTREAM_IDLE_TIMEOUT)
+            return (yanit, SseRewriter(custom, hedef=ad, tasma=self._tasma_ogren, aracsiz=self._aracsiz_ogren, tool_names=tool_names),
+                    f"[{n} {slug}=>{ad} devam]")
+        try:
+            bitis_turu = tur_bilgisi(req, sohbet)[1]
+            jev_bitis = jev_devam if jev_etkin and jev_settings.read()[0]["finishCheck"]["enabled"] else None
+            if jev_bitis is not None:
+                with KARAR_KILIDI:
+                    if bitis_turu in BITIS_TURLARI:
+                        jev_bitis = None        # bu turda bir kez geri verildi
+        except Exception:
+            jev_bitis = None
         # A 9Router combo (Fusion-*, no provider prefix) runs a whole panel upstream. Once it may
         # have started (timeout, 504, cut stream) resending it runs and bills it twice (28 Sep 2026);
         # only failures before the work starts (no connection, 500/502/503/529) are retried.
@@ -1799,7 +2027,7 @@ class H(http.server.BaseHTTPRequestHandler):
                 time.sleep(min(2 * attempt, 8)); continue
             # Only the resolved exact voice target owns this sideband protocol.
             # Other models retain their original response/Jev/stream pipeline.
-            if target == 'Sesli-Hizli-Zeki':
+            if jev_denetim.izleme_mi(target):
                 # Capture was taken before rewriting/request dispatch. Only this exact
                 # route credential may authenticate the returned public receipt.
                 correlation = self.watch_correlation
@@ -1821,7 +2049,9 @@ class H(http.server.BaseHTTPRequestHandler):
                 log(f"{tag} ozet kopru: {akis.sonuc_notu()}")
                 return sonuc
             if jev_etkin and resp.status == 200:
-                return self._denetimli_akis(resp, tag, rewriter, izle, jev_istek, jev_sira, jev_ac, hedef=target)
+                # devam yalniz finishCheck acikken gecer; kapaliyken cagri eskisiyle birebir aynidir.
+                return self._denetimli_akis(resp, tag, rewriter, izle, jev_istek, jev_sira, jev_ac, hedef=target,
+                                            **({"devam": jev_bitis} if jev_bitis else {}))
             return self._stream(resp, resp.status, tag, rewriter, izle)
         if jev_etkin:                # secili modele ulasilamadi: adimi siradaki katman yapar
             return self._denetimli_akis(None, tag, rewriter, izle, jev_istek, jev_sira, jev_ac, hedef=target)
@@ -1838,13 +2068,24 @@ class WatchResponse:
     def __init__(self, response, accept):
         self.response, self.filter = response, MetadataFilter(accept)
         self.done = False
+        self.gecis = False      # suzgec tasti (cok buyuk cerceve): kalan akis oldugu gibi gecer
     def __getattr__(self, name):
         return getattr(self.response, name)
     def read1(self, size):
+        if self.gecis:
+            return self.response.read1(size)
         while not self.done:
             raw = self.response.read1(size)
             if raw:
-                data = self.filter.feed(raw)
+                try:
+                    data = self.filter.feed(raw)
+                except ValueError:
+                    # 256 KB'i asan tek cerceve: akisi dusurmek yerine suzgecsiz devam (yan kanal cercevesi
+                    # bu boyda olmaz). Tamponda yan kanal varsa disari cikmaz.
+                    data, self.filter.frames.buf = self.filter.frames.buf, b''
+                    self.gecis = True
+                    log("izleme suzgeci: cok buyuk SSE cercevesi, kalan akis suzgecsiz geciyor")
+                    return b'' if b'bekci.watch' in data else data
                 if data: return data
             else:
                 self.done = True

apps/desktop/assets/codex-bridge/pencere.py

@@ -221,7 +221,7 @@ def _yapraklar(dugum, derinlik=0):
     return cikti
 
 
-def coz(kimlik, tur, yol, kayit=None, nano=None, ogr=None, aracsiz=()):
+def coz(kimlik, tur, yol, kayit=None, nano=None, ogr=None, aracsiz=(), ilan=None):
     """Bir katalog girdisinin ilan edilecek penceresi ve yetenekleri.
     kimlik: gecit kimligi; tur: "combo" | "model"; yol: gecidin aciklamasindaki "saglayici/model" yolu;
     kayit: /router/catalog girdisi (combo topolojisi icin). Donus: {"pencere","gorsel","arac","kaynak"}."""
@@ -246,6 +246,13 @@ def coz(kimlik, tur, yol, kayit=None, nano=None, ogr=None, aracsiz=()):
             m = re.match(r"no-think-(?:9router-)?([a-z0-9]+)-", kimlik or "")
             yol = (m.group(1) + "/" + yol[len("no-think/"):]) if m else yol
         sonuc = yol_bilgisi(yol, nano) or dict(bilinmeyen)
+    # Exact /models metadata is stronger evidence than name-based local
+    # fallbacks. Do not infer a combo's capacity from its display name.
+    ilan = ilan if isinstance(ilan, dict) else {}
+    canli_sinirlar = [ilan[k] for k in ("context_length", "max_input_tokens")
+                      if type(ilan.get(k)) is int and TABAN <= ilan[k] <= 10_000_000]
+    if canli_sinirlar:
+        sonuc = {**sonuc, "pencere": min(canli_sinirlar), "kaynak": "saglayici-katalogu"}
     if kimlik in aracsiz:
         sonuc = {**sonuc, "arac": False}
     sinir = (ogr or {}).get(kimlik)

apps/desktop/assets/codex-bridge/terminal_stream.py

@@ -0,0 +1,119 @@
+"""Transport-only handling of a worker's explicit terminal failure.
+
+Never selects a model, evaluates content, or changes worker/Jev decisions.
+If HTTP headers have already gone out, remember the failure for exactly one
+identical retry. Codex then receives an HTTP error instead of re-running the
+whole exhausted provider chain. Ordinary network interruptions remain retries.
+"""
+import hashlib
+import json
+import threading
+import time
+from collections import OrderedDict
+
+
+def request_key(request, headers):
+    principal = "\0".join(headers.get(name, "") for name in
+                          ("Authorization", "ChatGPT-Account-Id", "session_id"))
+    body = json.dumps(request, sort_keys=True, ensure_ascii=False, separators=(",", ":"))
+    return hashlib.sha256((principal + "\0" + body).encode()).digest()
+
+
+class FailureReplays:
+    def __init__(self, ttl=120, capacity=128, clock=time.monotonic):
+        self.ttl, self.capacity, self.clock = ttl, capacity, clock
+        self.items = OrderedDict()
+        self.lock = threading.Lock()
+
+    def remember(self, key, error):
+        with self.lock:
+            self.items[key] = (self.clock() + self.ttl, error)
+            self.items.move_to_end(key)
+            while len(self.items) > self.capacity:
+                self.items.popitem(last=False)
+
+    def take(self, key):
+        with self.lock:
+            entry = self.items.pop(key, None)
+        return entry[1] if entry and entry[0] > self.clock() else None
+
+
+def error_body(error):
+    # Preserve the actual provider failure; don't relabel it invalid_prompt,
+    # fabricate response.completed, or expose a rejected model response.
+    return {"error": {"type": "upstream_terminal_error", "code": error["code"],
+                      "message": "Model yanıtı hata ile sonlandı. " + error["message"]}}
+
+
+class Observer:
+    """Bounded SSE observer. Forwarded stream bytes are never rewritten."""
+    LIMIT = 65536
+
+    def __init__(self):
+        self.tail = b""
+        self.data = []
+        self.size = 0
+        self.discard = False
+        self.discard_line = False
+        self.comment_seen = False
+        self.payload_seen = False
+        self.completed = False
+        self.error = None
+
+    def feed(self, chunk):
+        # read1() supplies small chunks, but also bound arbitrary caller input.
+        for offset in range(0, len(chunk), 4096):
+            self.tail += chunk[offset:offset + 4096]
+            while b"\n" in self.tail:
+                line, self.tail = self.tail.split(b"\n", 1)
+                if self.discard_line:
+                    self.discard_line = False
+                    continue
+                self._line(line.rstrip(b"\r"))
+            if len(self.tail) > self.LIMIT:
+                self.tail = b""
+                self.discard = self.discard_line = True
+
+    def _line(self, line):
+        if line.startswith(b":"):
+            self.comment_seen = True
+        elif line.startswith(b"data:"):
+            self.size += len(line)
+            if self.size > self.LIMIT:
+                self.discard = True
+                self.data.clear()
+            elif not self.discard:
+                self.data.append(line[5:].lstrip())
+        elif not line:
+            if self.data and not self.discard:
+                self._event(b"\n".join(self.data))
+            elif self.discard:
+                self.payload_seen = True
+            self.data, self.size, self.discard = [], 0, False
+
+    def _event(self, data):
+        try:
+            event = json.loads(data)
+        except (ValueError, UnicodeError):
+            self.payload_seen = True
+            return
+        if not isinstance(event, dict):
+            self.payload_seen = True
+            return
+        kind = event.get("type")
+        response = event.get("response")
+        error = event.get("error") if kind == "error" else response.get("error") if isinstance(response, dict) else None
+        # Known worker terminal errors only. Preserve context/rate-limit and
+        # other native error classifications rather than guessing semantics.
+        is_failure = (kind == "error" and isinstance(error, dict)
+                      and error.get("type") == "upstream_error")
+        is_failure |= (kind == "response.failed" and isinstance(error, dict)
+                       and error.get("code") == "jev_no_fallback")
+        if is_failure:
+            self.error = {"code": str(error.get("code") or "upstream_error")[:100],
+                          "message": str(error.get("message") or "Sağlayıcı yanıtı tamamlanamadı.")[:2000]}
+        else:
+            self.payload_seen = True
+        if kind == "response.completed":
+            self.completed = True
+            self.error = None

apps/desktop/assets/codex-bridge/test_agent_payload.py

@@ -0,0 +1,52 @@
+"""Regression fixture matching actual Codex child delivery, with no user data."""
+import copy
+import unittest
+
+import gecis_context
+import kopru
+
+
+class AgentPayloadTests(unittest.TestCase):
+    def request(self, text):
+        return {"model": "ide/test", "input": [{
+            "type": "agent_message", "author": "/root", "recipient": "/root/test",
+            "content": [
+                {"type": "input_text", "text": "Message Type: NEW_TASK\nPayload:\n"},
+                {"type": "encrypted_content", "encrypted_content": text},
+            ],
+        }]}
+
+    def test_actual_peer_wrapper_survives_external_text_extraction(self):
+        task = "Run exec_command: Write-Output (157 * 29); report the exit code."
+        request = self.request(task)
+        original = copy.deepcopy(request)
+        kopru.flatten_request(request)
+        # An OpenAI-compatible translator consumes input_text, not Codex's
+        # encrypted_content part. Checking the JSON string alone misses loss.
+        text = "\n".join(part["text"] for item in request["input"]
+                         for part in item["content"] if part["type"] == "input_text")
+        self.assertIn(task, text)
+        self.assertIn('/root/test', text)
+        self.assertEqual(request["input"][0]["role"], "user")
+        self.assertEqual(original["input"][0]["content"][1]["type"], "encrypted_content")
+
+    def test_peer_result_and_plain_parts_keep_order_without_source_mutation(self):
+        request = self.request("Result: 4553; exit code: 0")
+        original = copy.deepcopy(request)
+        result = gecis_context.portable_reasoning(request)
+        self.assertEqual(result["input"][0]["content"][-1]["text"], "Result: 4553; exit code: 0")
+        self.assertEqual(request, original)
+
+    def test_opaque_peer_payload_fails_instead_of_sending_header_only(self):
+        for opaque in ("gAAAA_native_ciphertext", "A" * 200, None):
+            with self.subTest(opaque=opaque):
+                with self.assertRaises(gecis_context.TransferError):
+                    gecis_context.portable_reasoning(self.request(opaque))
+
+    def test_reasoning_ciphertext_is_still_not_interpreted_as_a_peer_task(self):
+        request = {"input": [{"type": "reasoning", "encrypted_content": "Run a command now"}]}
+        self.assertEqual(gecis_context.portable_reasoning(request)["input"], [])
+
+
+if __name__ == "__main__":
+    unittest.main()

apps/desktop/assets/codex-bridge/test_gecis_context.py

@@ -22,6 +22,26 @@ from test_model_switch import env
 
 
 class History(unittest.TestCase):
+    def test_agent_task_survives_external_projection_and_recent_history(self):
+        task = {"type": "agent_message", "id": "amsg_task", "author": "/root",
+                "recipient": "/root/child", "content": [
+                    {"type": "input_text", "text": "Message Type: NEW_TASK\nRun CHILD_TOOL_410962"}]}
+        req = {"input": [{"role": "user", "content": "Old setup"}, task]}
+        before = copy.deepcopy(req)
+        self.assertEqual(gc.normalize(req), before)
+        projected = gc.portable_reasoning(req)
+        message = projected["input"][-1]
+        self.assertEqual(message["role"], "user")
+        self.assertEqual(message["content"][1:], task["content"])
+        self.assertIn('/root/child', message["content"][0]["text"])
+        self.assertNotIn("id", message)
+        self.assertEqual(gc.split_history(projected["input"], keep_users=1)[2], [message])
+        self.assertEqual(req, before)
+        self.assertEqual(gc.portable_reasoning(projected), projected)
+        direct = copy.deepcopy(req)
+        env["flatten_request"](direct)
+        self.assertEqual(direct["input"][-1], message)
+
     def test_native_function_results_are_not_foreign_or_renamed(self):
         req = {"input": [{"type": "function_call_output", "id": "fco_native",
                           "call_id": "call_native", "output": "kept"}]}

apps/desktop/assets/codex-bridge/test_jev_denetim.py

@@ -1,5 +1,7 @@
 """Layer check (11 Oct 2026): Jev passes or blocks each step of Katman-1..3; a blocked step is redone by the next
-layer. Katman-4 is never asked. No exceptions."""
+layer. The last layer is never asked. No exceptions.
+
+14 Oct 2026 defaults: Katman-1 -> Katman-2 -> Katman-3; Katman-3, Chat-Model and bekci-sesli-bekci always pass."""
 import ast
 import io
 import json
@@ -60,18 +62,19 @@ class Karar(unittest.TestCase):
 
 class Katman(unittest.TestCase):
     def test_a_non_layer_model_falls_through_every_layer_from_the_top(self):
-        self.assertEqual(jev_denetim.sonrakiler("Uncensored-Uygulama"),
-                         ["Katman-1", "Katman-2", "Katman-3", "Katman-4"])
-        self.assertEqual(jev_denetim.sonrakiler("ide/some-model"),
-                         ["Katman-1", "Katman-2", "Katman-3", "Katman-4"])
+        self.assertEqual(jev_denetim.sonrakiler("Uncensored-Uygulama"), ["Katman-1", "Katman-2", "Katman-3"])
+        self.assertEqual(jev_denetim.sonrakiler("ide/some-model"), ["Katman-1", "Katman-2", "Katman-3"])
 
     def test_a_selected_layer_only_tries_the_ones_after_it(self):
-        self.assertEqual(jev_denetim.sonrakiler("Katman-1"), ["Katman-2", "Katman-3", "Katman-4"])
-        self.assertEqual(jev_denetim.sonrakiler("Katman-2"), ["Katman-3", "Katman-4"])
-        self.assertEqual(jev_denetim.sonrakiler("Katman-3"), ["Katman-4"])
+        self.assertEqual(jev_denetim.sonrakiler("Katman-1"), ["Katman-2", "Katman-3"])
+        self.assertEqual(jev_denetim.sonrakiler("Katman-2"), ["Katman-3"])
+        # The always-pass last layer only uses the general fallback on transport failure; no revisits.
+        self.assertEqual(jev_denetim.sonrakiler("Katman-3"), ["Katman-1", "Katman-2"])
 
     def test_last_layer_is_never_asked(self):
-        self.assertTrue(jev_denetim.muaf_mi("Katman-4"))
+        self.assertTrue(jev_denetim.muaf_mi("Katman-3"))
+        self.assertTrue(jev_denetim.muaf_mi("Chat-Model"))
+        self.assertFalse(jev_denetim.muaf_mi("Katman-4"))
         self.assertEqual(jev_denetim.sonrakiler(None), [])
 
 
@@ -139,7 +142,7 @@ class Akis(unittest.TestCase):
         self.h.send_response = Mock()
         self.h.send_header = Mock()
         self.h.end_headers = Mock()
-        self.cevap = {"Katman-1": sse("bir"), "Katman-2": sse("iki"), "Katman-3": sse("uc"), "Katman-4": sse("dort")}
+        self.cevap = {"Katman-1": sse("bir"), "Katman-2": sse("iki"), "Katman-3": sse("uc")}
 
     def sor(self, istek, metin, key):
         self.asked.append(metin)
@@ -162,7 +165,7 @@ class Akis(unittest.TestCase):
             raw = rest[n + 2:]
         return out
 
-    def calistir(self, body, sira=("Katman-2", "Katman-3", "Katman-4")):
+    def calistir(self, body, sira=("Katman-2", "Katman-3")):
         self.h._denetimli_akis(Yanit(body), "[1]", None, None, "yap", list(sira), self.ac)
 
     def test_a_passed_step_is_delivered_unchanged(self):
@@ -176,7 +179,7 @@ class Akis(unittest.TestCase):
         body = sse("Bunu yapamam.")
         self.puanlar = [{"ret": 0.9, "sart": 0.0}]
         self.h._denetimli_akis(Yanit(body), "[1]", None, None, "yap",
-                              list(jev_denetim.KATMAN), self.ac, hedef="Sesli-Hizli-Zeki")
+                              list(jev_denetim.KATMAN), self.ac, hedef="Chat-Model")
         self.assertEqual(self.sent(), body)
         self.assertEqual(self.asked, [])
         self.assertEqual(self.opened, [])
@@ -184,14 +187,13 @@ class Akis(unittest.TestCase):
     def test_voice_transport_failure_still_checks_the_fallback_model(self):
         self.puanlar = [{"ret": 0.9, "sart": 0.0}]
         self.h._denetimli_akis(None, "[1]", None, None, "yap",
-                              list(jev_denetim.KATMAN), self.ac, hedef="Sesli-Hizli-Zeki")
+                              list(jev_denetim.KATMAN), self.ac, hedef="Chat-Model")
         self.assertEqual(self.opened, ["Katman-1", "Katman-2"])
         self.assertEqual(self.asked, ["bir", "iki"])
         self.assertEqual(self.sent(), self.cevap["Katman-2"])
 
     def test_voice_lookalikes_are_still_checked(self):
-        for target in ("sesli-hizli-zeki", "Sesli-Hizli-Zeki-v2", "ide/Sesli-Hizli-Zeki",
-                       "Sesli-Hizli-Zeki ", "Other-Combo"):
+        for target in ("chat-model", "Chat-Model-v2", "ide/Chat-Model", "Chat-Model ", "Other-Combo"):
             with self.subTest(target=target):
                 self.setUp()
                 self.puanlar = [{"ret": 0.9, "sart": 0.0}]
@@ -202,7 +204,7 @@ class Akis(unittest.TestCase):
 
     def test_a_blocked_non_layer_model_goes_to_layer_1_first(self):
         self.puanlar = [{"ret": 0.9, "sart": 0.0}]          # the selected (non-layer) model is blocked
-        self.calistir(sse("Bunu yapamam."), sira=("Katman-1", "Katman-2", "Katman-3", "Katman-4"))
+        self.calistir(sse("Bunu yapamam."), sira=("Katman-1", "Katman-2", "Katman-3"))
         self.assertEqual(self.sent(), self.cevap["Katman-1"])
         self.assertEqual(self.opened, ["Katman-1"])
         self.assertEqual(self.asked, ["Bunu yapamam.", "bir"])
@@ -216,17 +218,17 @@ class Akis(unittest.TestCase):
         self.assertEqual(self.asked, ["Bunu yapamam.", "iki"])
         self.h.send_response.assert_called_once()
 
-    def test_every_layer_blocked_ends_at_layer_4_unasked(self):
-        self.puanlar = [{"ret": 0.9, "sart": 0.0}] * 3
+    def test_every_layer_blocked_ends_at_layer_3_unasked(self):
+        self.puanlar = [{"ret": 0.9, "sart": 0.0}] * 2
         self.calistir(sse("hayir"))
-        self.assertEqual(self.sent(), self.cevap["Katman-4"])
-        self.assertEqual(self.opened, ["Katman-2", "Katman-3", "Katman-4"])
-        self.assertEqual(self.asked, ["hayir", "iki", "uc"])          # layer 4 is never asked
+        self.assertEqual(self.sent(), self.cevap["Katman-3"])
+        self.assertEqual(self.opened, ["Katman-2", "Katman-3"])
+        self.assertEqual(self.asked, ["hayir", "iki"])          # the always-pass last layer is never asked
 
-    def test_blocked_layer_3_goes_straight_to_layer_4(self):
+    def test_blocked_layer_2_goes_straight_to_layer_3(self):
         self.puanlar = [{"ret": 0.0, "sart": 0.8}]
-        self.calistir(sse("kendi sartimla"), sira=("Katman-4",))
-        self.assertEqual(self.sent(), self.cevap["Katman-4"])
+        self.calistir(sse("kendi sartimla"), sira=("Katman-3",))
+        self.assertEqual(self.sent(), self.cevap["Katman-3"])
         self.assertEqual(self.asked, ["kendi sartimla"])
 
     def test_a_layer_that_cannot_be_opened_is_skipped(self):
@@ -329,13 +331,13 @@ class Akis(unittest.TestCase):
 
     def test_when_no_layer_opens_the_blocked_answer_is_not_delivered(self):
         self.puanlar = [{"ret": 0.9, "sart": 0.0}]
-        self.cevap.update({"Katman-2": None, "Katman-3": None, "Katman-4": None})
+        self.cevap.update({"Katman-2": None, "Katman-3": None})
         self.calistir(sse("Bunu yapamam."))
-        self.assertEqual(self.opened, ["Katman-2", "Katman-3", "Katman-4"])
+        self.assertEqual(self.opened, ["Katman-2", "Katman-3"])
         self.assertNotIn(b"yapamam", self.h.wfile.getvalue())
         self.assertIn(b'response.failed', self.sent())
 
-    def test_the_last_layers_own_error_body_is_delivered_untouched(self):
+    def test_last_layer_http_error_terminates_sse_without_leaking_raw_body(self):
         class Hata(Exception):
             def read(self):
                 return b'{"error": {"message": "katman 4 hatasi"}}'
@@ -344,7 +346,14 @@ class Akis(unittest.TestCase):
         def ac(ad):
             raise Hata("HTTP 400")
         self.h._denetimli_akis(Yanit(sse("Bunu yapamam.")), "[1]", None, None, "yap", ["Katman-4"], ac)
-        self.assertEqual(self.sent(), b'{"error": {"message": "katman 4 hatasi"}}')
+        raw = self.sent()
+        self.assertTrue(raw.startswith(b"event: response.failed\ndata: "))
+        event = json.loads(raw.split(b"data: ", 1)[1])
+        self.assertEqual(event["response"]["status"], "failed")
+        self.assertEqual(event["response"]["error"]["code"], "jev_no_fallback")
+        self.assertEqual(event["response"]["output"], [])
+        self.assertNotIn(b"katman 4 hatasi", raw)
+        self.assertNotIn(b"Bunu yapamam", raw)
 
     def test_unreachable_jev_keeps_the_answer(self):
         self.puanlar = [None]

apps/desktop/assets/codex-bridge/test_karar_asamalari.py

@@ -0,0 +1,550 @@
+"""Decision stages (14 Oct 2026): settings schema 2, turn-start decisions, layer window filter, finish check
+and Dify rules. Every new stage is off by default; the tests turn them on explicitly."""
+import ast
+import copy
+import hashlib
+import io
+import json
+import threading
+import tempfile
+import time
+import unittest
+from pathlib import Path
+from unittest.mock import Mock, patch
+
+import jev_denetim
+import jev_settings
+import karar_politikasi
+import model_gecis
+import pencere
+import yarim
+from test_jev_denetim import Yanit, method, sse, user
+
+SOURCE = Path(__file__).with_name("kopru.py").read_text(encoding="utf-8")
+TREE = ast.parse(SOURCE)
+
+
+def fonksiyon(name):
+    return next(n for n in TREE.body if isinstance(n, ast.FunctionDef) and n.name == name)
+
+
+class Ev(unittest.TestCase):
+    """A temporary bridge home with a settings file."""
+
+    def setUp(self):
+        self.tmp = tempfile.TemporaryDirectory()
+        self.addCleanup(self.tmp.cleanup)
+        self.home = Path(self.tmp.name)
+        p = patch.object(jev_settings, 'home', return_value=self.home)
+        p.start()
+        self.addCleanup(p.stop)
+        self.settings = copy.deepcopy(jev_settings.DEFAULTS)
+
+    def save(self, settings=None, **extra):
+        data = {'settings': settings if settings is not None else self.settings}
+        data.update(extra)
+        (self.home / 'jev-settings.json').write_text(json.dumps(data), encoding='utf-8')
+
+
+class Ayarlar(Ev):
+    def test_a_schema_1_file_gets_every_new_stage_disabled(self):
+        eski = {k: v for k, v in self.settings.items() if k not in jev_settings.SECTIONS}
+        self.save(eski)
+        s, _ = jev_settings.read()
+        for bolum in ('prefilter', 'autoRoute', 'finishCheck', 'verifierCheck'):
+            self.assertFalse(s[bolum]['enabled'], bolum)
+        self.assertEqual(s['policy']['source'], 'local')
+        self.assertEqual(s['watchModels'], jev_settings.DEFAULTS['watchModels'])
+
+    def test_a_partial_section_keeps_written_values_and_fills_the_rest(self):
+        self.settings['prefilter'] = {'enabled': True, 'threshold': 0.8}
+        self.save()
+        p = jev_settings.read()[0]['prefilter']
+        self.assertEqual((p['enabled'], p['threshold']), (True, 0.8))
+        self.assertEqual(p['target'], jev_settings.DEFAULTS['prefilter']['target'])
+
+    def test_bad_values_are_rejected(self):
+        for bolum, alan, deger in (('prefilter', 'threshold', 1.5), ('prefilter', 'timeoutSeconds', 0),
+                                   ('autoRoute', 'model', ''), ('finishCheck', 'note', ''),
+                                   ('policy', 'endpoint', 'http://dify.example'), ('policy', 'source', 'web')):
+            with self.subTest(bolum=bolum, alan=alan):
+                s = copy.deepcopy(self.settings)
+                s[bolum][alan] = deger
+                self.save(s)
+                with self.assertRaises(ValueError):
+                    jev_settings.read()
+
+    def test_automatic_model_cannot_target_itself(self):
+        self.settings['autoRoute']['targets']['zor'] = 'Otomatik'
+        self.save()
+        with self.assertRaises(ValueError):
+            jev_settings.read()
+
+    def test_watch_channel_is_an_exact_name_from_settings(self):
+        self.settings['watchModels'] = ['Chat-Model']
+        self.save()
+        self.assertTrue(jev_denetim.izleme_mi('Chat-Model'))
+        for ad in ('chat-model', 'Chat-Model ', 'ide/Chat-Model', 'Sesli-Hizli-Zeki'):
+            self.assertFalse(jev_denetim.izleme_mi(ad), ad)
+
+
+class Politika(Ev):
+    def test_dify_rules_apply_only_when_the_source_is_dify_and_they_are_valid(self):
+        (self.home / jev_settings.POLICY_FILE).write_text(json.dumps(
+            {'ok': True, 'overrides': {'prefilter': {'enabled': True, 'target': 'Katman-3'}}}), encoding='utf-8')
+        self.save()
+        self.assertFalse(jev_settings.read()[0]['prefilter']['enabled'])            # source local
+        self.settings['policy']['source'] = 'dify'
+        self.save()
+        p = jev_settings.read()[0]['prefilter']
+        self.assertEqual((p['enabled'], p['target']), (True, 'Katman-3'))
+        self.assertFalse(jev_settings.read(overlay=False)[0]['prefilter']['enabled'])
+        (self.home / jev_settings.POLICY_FILE).write_text(json.dumps(
+            {'ok': True, 'overrides': {'prefilter': {'threshold': 7}}}), encoding='utf-8')
+        self.assertFalse(jev_settings.read()[0]['prefilter']['enabled'])            # invalid rules: local in force
+
+    def test_rules_cannot_change_the_chain_or_unknown_sections(self):
+        s = jev_settings.read(overlay=False)[0]
+        with self.assertRaises(ValueError):
+            karar_politikasi.ayikla({'exemptModels': {'x': 1}}, s)
+        with self.assertRaises(ValueError):
+            karar_politikasi.ayikla({'autoRoute': {'targets': {'zor': 'Otomatik'}}}, s)
+        with self.assertRaises(ValueError):
+            karar_politikasi.ayikla('[1, 2]', s)
+        self.assertEqual(karar_politikasi.ayikla('{"autoRoute": {"enabled": true}}', s), {'autoRoute': {'enabled': True}})
+
+    def test_fetch_reads_the_kurallar_output_and_never_raises(self):
+        s = jev_settings.read(overlay=False)[0]
+
+        def yanit(govde):
+            r = Mock()
+            r.__enter__ = lambda self_: self_
+            r.__exit__ = lambda *a: False
+            r.read = lambda n=-1: json.dumps(govde).encode()
+            return r
+        istekler = []
+
+        def urlopen(req, timeout):
+            istekler.append(req)
+            return yanit({'data': {'outputs': {'kurallar': {'finishCheck': {'enabled': True}}}}})
+        sonuc = karar_politikasi.cek(s, 'app-key', urlopen=urlopen)
+        self.assertEqual(sonuc, {'ok': True, 'overrides': {'finishCheck': {'enabled': True}}})
+        self.assertTrue(istekler[0].full_url.endswith('/workflows/run'))
+        self.assertEqual(istekler[0].get_header('Authorization'), 'Bearer app-key')
+        self.assertFalse(karar_politikasi.cek(s, '', urlopen=urlopen)['ok'])
+        self.assertFalse(karar_politikasi.cek(s, 'k', urlopen=Mock(side_effect=OSError('kapali')))['ok'])
+        bos = karar_politikasi.cek(s, 'k', urlopen=lambda req, timeout: yanit({'data': {'outputs': {}}}))
+        self.assertEqual(bos['ok'], False)
+
+    def test_a_failed_fetch_keeps_the_last_good_rules(self):
+        jev_settings.write_policy({'ok': True, 'overrides': {'finishCheck': {'enabled': True}}})
+        kayit = jev_settings.write_policy({'ok': False, 'error': 'Dify kapali'})
+        self.assertTrue(kayit['ok'])
+        self.assertEqual(kayit['overrides'], {'finishCheck': {'enabled': True}})
+        self.assertEqual(kayit['error'], 'Dify kapali')
+        self.settings['policy']['source'] = 'dify'
+        self.save()
+        self.assertTrue(jev_settings.read()[0]['finishCheck']['enabled'])
+
+
+class OnKarar(Ev):
+    def gonder(self, cevap):
+        self.govdeler = []
+
+        def f(govde, key):
+            self.govdeler.append(govde)
+            if isinstance(cevap, Exception):
+                raise cevap
+            return {'answers': {k: {'noul': v} for k, v in cevap.items()}}
+        return f
+
+    def test_automatic_routing_picks_research_then_hard_then_simple(self):
+        self.settings['autoRoute']['enabled'] = True
+        self.save()
+        t = self.settings['autoRoute']['targets']
+        for puan, hedef in (({'zor': 0.9, 'arastirma': 0.8}, t['arastirma']), ({'zor': 0.9, 'arastirma': 0.1}, t['zor']),
+                            ({'zor': 0.1, 'arastirma': 0.1}, t['basit'])):
+            sonuc = jev_denetim.on_karar('istek', True, False, 'k', gonder=self.gonder(puan))
+            self.assertEqual(sonuc['hedef'], hedef)
+            self.assertEqual(set(self.govdeler[0]['questions']), {'zor', 'arastirma'})
+            self.assertNotIn('assistant_reply', self.govdeler[0]['state'])
+
+    def test_no_decision_falls_to_the_strong_target(self):
+        self.settings['autoRoute']['enabled'] = True
+        self.save()
+        sonuc = jev_denetim.on_karar('istek', True, False, 'k', gonder=self.gonder(OSError('yok')))
+        self.assertEqual((sonuc['hedef'], sonuc['ret']), (self.settings['autoRoute']['targets']['zor'], None))
+
+    def test_refusal_question_goes_in_the_same_call(self):
+        self.settings['autoRoute']['enabled'] = True
+        self.settings['prefilter']['enabled'] = True
+        self.save()
+        sonuc = jev_denetim.on_karar('istek', True, True, 'k', gonder=self.gonder({'zor': 0.1, 'arastirma': 0.1, 'ret': 0.9}))
+        self.assertEqual(len(self.govdeler), 1)
+        self.assertEqual(set(self.govdeler[0]['questions']), {'zor', 'arastirma', 'ret'})
+        self.assertTrue(sonuc['ret'])
+
+    def test_a_missing_answer_is_no_decision(self):
+        self.settings['prefilter']['enabled'] = True
+        self.save()
+        sonuc = jev_denetim.on_karar('istek', False, True, 'k', gonder=self.gonder({}))
+        self.assertIsNone(sonuc['ret'])
+
+
+class TurBasi(Ev):
+    """kopru.karar_asamasi through its own source."""
+
+    def setUp(self):
+        super().setUp()
+        self.kararlar = []
+        self.logs = []
+        sahte_denetim = Mock(wraps=jev_denetim)
+        sahte_denetim.anahtar = lambda: 'k'
+        sahte_denetim.on_karar = self.on_karar
+        sahte_denetim.muaf_mi = jev_denetim.muaf_mi
+        sahte_denetim.sonrakiler = jev_denetim.sonrakiler
+        sahte_denetim.son_istek = jev_denetim.son_istek
+        self.cevap = {'hedef': None, 'ret': None, 'puan': None}
+        sahte_denetim.son_istek_sirasi = jev_denetim.son_istek_sirasi
+        sahte_denetim.istek_metni = jev_denetim.istek_metni
+        self.env = {'IDE_PREFIX': 'ide/', 'ON_KARAR': {}, 'ON_KARAR_SINIR': 3, 'jev_settings': jev_settings,
+                    'jev_denetim': sahte_denetim, 'model_gecis': model_gecis, 'hashlib': hashlib, 'time': time,
+                    'json': json, 'KARAR_KILIDI': threading.Lock(), 'BITIS_TURLARI': {}, 'log': self.logs.append}
+        govde = [fonksiyon(a) for a in ('tur_bilgisi', 'karar_asamasi', 'bitis_kullan')]
+        exec(compile(ast.Module(body=govde, type_ignores=[]), 'kopru.py', 'exec'), self.env)
+        self.karar = self.env['karar_asamasi']
+
+    def on_karar(self, istek, oto, ret, key):
+        self.kararlar.append((istek, oto, ret))
+        return dict(self.cevap)
+
+    def istek(self, model, *girdi):
+        return {'model': model, 'prompt_cache_key': 'sohbet-1', 'input': list(girdi)}
+
+    def test_everything_off_changes_nothing_and_asks_nothing(self):
+        self.save()
+        for model in ('ide/Ajan', 'ide/codex-gpt-6-astra', 'ide/Chat-Model'):
+            req = self.istek(model, user('yap'))
+            self.assertEqual(self.karar(1, req, 'sohbet-1', model), model)
+            self.assertEqual(req['model'], model)
+        self.assertEqual(self.kararlar, [])
+
+    def test_automatic_choice_is_kept_for_the_tool_steps_of_the_same_turn(self):
+        self.settings['autoRoute']['enabled'] = True
+        self.save()
+        self.cevap = {'hedef': 'Arastirma', 'ret': None, 'puan': {'zor': 0.2, 'arastirma': 0.9}}
+        req = self.istek('ide/Otomatik', user('kaynaklari karsilastir'))
+        self.assertEqual(self.karar(1, req, 'sohbet-1', 'ide/Otomatik'), 'ide/Arastirma')
+        self.assertEqual(req['model'], 'ide/Arastirma')
+        arac = {'type': 'function_call_output', 'call_id': 'c1', 'output': 'ok'}
+        req2 = self.istek('ide/Otomatik', user('kaynaklari karsilastir'), {'type': 'function_call', 'call_id': 'c1'}, arac)
+        self.assertEqual(self.karar(2, req2, 'sohbet-1', 'ide/Otomatik'), 'ide/Arastirma')
+        self.assertEqual(len(self.kararlar), 1)                      # same turn: no second question
+        son_cevap = {'type': 'message', 'role': 'assistant', 'content': [{'type': 'output_text', 'text': 'Rapor hazir.'}]}
+        req3 = self.istek('ide/Otomatik', user('kaynaklari karsilastir'), arac, son_cevap, user('simdi kodu duzelt'))
+        self.cevap = {'hedef': 'Ajan', 'ret': None, 'puan': {'zor': 0.9, 'arastirma': 0.1}}
+        self.assertEqual(self.karar(3, req3, 'sohbet-1', 'ide/Otomatik'), 'ide/Ajan')
+        self.assertEqual(len(self.kararlar), 2)                      # new user message: new decision
+
+    def test_predicted_refusal_starts_at_the_configured_layer(self):
+        self.settings['prefilter']['enabled'] = True
+        self.save()
+        self.cevap = {'hedef': None, 'ret': True, 'puan': {'ret': 0.9}}
+        req = self.istek('ide/codex-gpt-6-astra', user('sert bir roast yaz'))
+        self.assertEqual(self.karar(1, req, 'sohbet-1', 'ide/codex-gpt-6-astra'), 'ide/Katman-2')
+        self.assertEqual(self.kararlar, [('sert bir roast yaz', False, True)])
+
+    def test_exempt_and_later_layers_are_not_asked(self):
+        self.settings['prefilter']['enabled'] = True
+        self.save()
+        for model in ('ide/Chat-Model', 'ide/Katman-2', 'ide/Katman-3', 'codex/gpt-6-astra'):
+            req = self.istek(model, user('yap'))
+            self.assertEqual(self.karar(1, req, 'sohbet-1', model), model)
+        self.assertEqual(self.kararlar, [])
+
+    def test_no_refusal_or_no_decision_keeps_the_model(self):
+        self.settings['prefilter']['enabled'] = True
+        self.save()
+        for cevap in ({'hedef': None, 'ret': False, 'puan': {'ret': 0.1}}, {'hedef': None, 'ret': None, 'puan': None}):
+            self.env['ON_KARAR'].clear()
+            self.cevap = cevap
+            req = self.istek('ide/Ajan', user('yap'))
+            self.assertEqual(self.karar(1, req, 'sohbet-1', 'ide/Ajan'), 'ide/Ajan')
+            self.assertEqual(req['model'], 'ide/Ajan')
+
+    def test_master_switch_off_disables_every_stage(self):
+        self.settings['enabled'] = False
+        self.settings['prefilter']['enabled'] = True
+        self.settings['autoRoute']['enabled'] = True
+        self.save()
+        req = self.istek('ide/Otomatik', user('yap'))
+        # The virtual name never leaves the bridge; nothing is asked while the main switch is off.
+        self.assertEqual(self.karar(1, req, 'sohbet-1', 'ide/Otomatik'), 'ide/' + self.settings['autoRoute']['targets']['zor'])
+        self.assertEqual(self.kararlar, [])
+
+    def test_a_message_typed_mid_turn_or_a_dot_keeps_the_choice(self):
+        self.settings['autoRoute']['enabled'] = True
+        self.save()
+        self.cevap = {'hedef': 'Arastirma', 'ret': None, 'puan': {'zor': 0.2, 'arastirma': 0.9}}
+        bas = user('kaynaklari karsilastir')
+        cagri = {'type': 'function_call', 'call_id': 'c1', 'name': 'shell', 'arguments': '{}'}
+        cikti = {'type': 'function_call_output', 'call_id': 'c1', 'output': 'ok'}
+        self.assertEqual(self.karar(1, self.istek('ide/Otomatik', bas), 'sohbet-1', 'ide/Otomatik'), 'ide/Arastirma')
+        self.cevap = {'hedef': 'Workflow-Kesif', 'ret': None, 'puan': {'zor': 0.1, 'arastirma': 0.1}}
+        for ek in (user('.'), user('bir de sunu ekle'), {'type': 'compaction_trigger'}):
+            req = self.istek('ide/Otomatik', bas, cagri, cikti, ek)
+            self.assertEqual(self.karar(2, req, 'sohbet-1', 'ide/Otomatik'), 'ide/Arastirma', ek)
+        self.assertEqual(len(self.kararlar), 1)
+
+    def test_a_disabled_automatic_model_never_reaches_the_gateway(self):
+        self.save()                                                  # autoRoute off
+        req = self.istek('ide/Otomatik', user('yap'))
+        secilen = self.karar(1, req, 'sohbet-1', 'ide/Otomatik')
+        self.assertEqual(secilen, 'ide/' + self.settings['autoRoute']['targets']['zor'])
+        self.assertEqual(req['model'], secilen)
+        self.assertEqual(self.kararlar, [])
+        self.settings['autoRoute']['enabled'] = True
+        self.settings['enabled'] = False                             # main switch off
+        self.save()
+        self.assertNotEqual(self.karar(2, self.istek('ide/Otomatik', user('yap')), 'sohbet-1', 'ide/Otomatik'), 'ide/Otomatik')
+
+    def test_without_a_conversation_key_the_tool_steps_still_keep_the_choice(self):
+        self.settings['autoRoute']['enabled'] = True
+        self.save()
+        self.cevap = {'hedef': 'Ajan', 'ret': None, 'puan': {'zor': 0.9, 'arastirma': 0.1}}
+        bas = user('kodu duzelt')
+        self.assertEqual(self.karar(1, {'model': 'ide/Otomatik', 'input': [bas]}, '', 'ide/Otomatik'), 'ide/Ajan')
+        cikti = {'type': 'function_call_output', 'call_id': 'c1', 'output': 'ok'}
+        req = {'model': 'ide/Otomatik', 'input': [bas, {'type': 'function_call', 'call_id': 'c1'}, cikti]}
+        self.assertEqual(self.karar(2, req, '', 'ide/Otomatik'), 'ide/Ajan')
+        self.assertEqual(len(self.kararlar), 1)
+
+    def test_the_finish_retry_is_used_once_per_turn(self):
+        self.assertTrue(self.env['bitis_kullan']('tur-1'))
+        self.assertFalse(self.env['bitis_kullan']('tur-1'))
+        self.assertTrue(self.env['bitis_kullan']('tur-2'))
+
+    def test_turn_memory_is_bounded(self):
+        self.settings['prefilter']['enabled'] = True
+        self.save()
+        self.cevap = {'hedef': None, 'ret': False, 'puan': {'ret': 0.1}}
+        for i in range(6):
+            self.karar(i, {'model': 'ide/Ajan', 'prompt_cache_key': f's{i}', 'input': [user('yap')]}, f's{i}', 'ide/Ajan')
+        self.assertLessEqual(len(self.env['ON_KARAR']), 3)
+
+
+class KatmanPenceresi(unittest.TestCase):
+    def suzgec(self, bilgi):
+        logs = []
+        env = {'IDE_PREFIX': 'ide/', 'IDE_BILGI': bilgi, 'pencere': pencere, 'log': logs.append}
+        exec(compile(ast.Module(body=[fonksiyon('sigan_katmanlar')], type_ignores=[]), 'kopru.py', 'exec'), env)
+        return env['sigan_katmanlar'], logs
+
+    def test_a_layer_too_small_for_the_request_is_skipped(self):
+        f, logs = self.suzgec({'ide/Katman-2': {'pencere': 1000, 'kaynak': 'katalog'}, 'ide/Katman-3': {'pencere': 10 ** 6}})
+        req = {'input': [user('x' * 20000)]}
+        self.assertEqual(f(['Katman-2', 'Katman-3', 'Bilinmeyen'], req, '[1]'), ['Katman-3', 'Bilinmeyen'])
+        self.assertIn('Katman-2', logs[0])
+
+    def test_the_last_layer_and_untrusted_windows_are_never_skipped(self):
+        req = {'input': [user('x' * 20000)]}
+        f, _ = self.suzgec({'ide/Katman-2': {'pencere': 1000, 'kaynak': 'katalog'}, 'ide/Katman-3': {'pencere': 1000, 'kaynak': 'katalog'}})
+        self.assertEqual(f(['Katman-2', 'Katman-3'], req, '[1]'), ['Katman-3'])        # last one stays
+        f, _ = self.suzgec({'ide/Katman-2': {'pencere': 1000, 'kaynak': 'varsayilan'}})
+        self.assertEqual(f(['Katman-2', 'Katman-3'], req, '[1]'), ['Katman-2', 'Katman-3'])  # placeholder window
+
+
+class BitisDenetimi(Ev):
+    """_denetimli_akis with finishCheck: an answer that stops early goes back to the same model once."""
+
+    def setUp(self):
+        super().setUp()
+        self.settings['finishCheck']['enabled'] = True
+        self.save()
+        self.asked, self.logs, self.devamlar = [], [], []
+        self.puanlar = []
+        sahte = Mock()
+        sahte.anahtar = lambda: 'k'
+        sahte.sor = self.sor
+        sahte.karar = jev_denetim.karar
+        sahte.bitmedi_mi = jev_denetim.bitmedi_mi
+        sahte.hazirlik_mi = jev_denetim.hazirlik_mi
+        sahte.muaf_mi = jev_denetim.muaf_mi
+        sahte.hata_gecis = jev_denetim.hata_gecis
+        env = {'jev_denetim': sahte, 'yarim': yarim, 'time': time, 'http': __import__('http.client'),
+               'log': self.logs.append, 'RESP_HOP': set(), 'json': json}
+        adlar = ('_akis_basligi', '_denetimli_akis', '_stream')
+        exec(compile(ast.Module(body=[method(a) for a in adlar], type_ignores=[]), 'kopru.py', 'exec'), env)
+        self.h = type('H', (), {a: env[a] for a in adlar})()
+        self.h.wfile = io.BytesIO()
+        self.h.send_response = self.h.send_header = self.h.end_headers = Mock()
+
+    def sor(self, istek, metin, key, bitis=False):
+        self.asked.append((metin, bitis))
+        return self.puanlar.pop(0) if self.puanlar else {'ret': 0.0, 'sart': 0.0}
+
+    def devam(self, ad, onceki):
+        self.devamlar.append((ad, onceki))
+        return Yanit(sse('gercekten bitti, cikti: OK')), None, f'[{ad} devam]'
+
+    def calistir(self, body):
+        self.h._denetimli_akis(Yanit(body), '[1]', None, None, 'yap', ['Katman-1'], Mock(), hedef='Ajan', devam=self.devam)
+        return self.gonderilen()
+
+    def gonderilen(self):
+        raw, out = self.h.wfile.getvalue(), b''
+        while raw:
+            size, _, rest = raw.partition(b'\r\n')
+            n = int(size, 16)
+            if n == 0:
+                break
+            out += rest[:n]
+            raw = rest[n + 2:]
+        return out
+
+    def test_an_early_stop_goes_back_once_and_the_retry_is_delivered(self):
+        self.puanlar = [{'ret': 0.0, 'sart': 0.0, 'bitmedi': 0.9}, {'ret': 0.0, 'sart': 0.0, 'bitmedi': 0.9}]
+        out = self.calistir(sse('Bitti.'))
+        self.assertEqual(self.devamlar, [('Ajan', 'Bitti.')])
+        self.assertIn(b'gercekten bitti', out)
+        self.assertNotIn(b'"Bitti."', out)
+        self.assertEqual([b for _, b in self.asked], [True, False])   # the retry is not asked again
+
+    def test_a_finished_answer_is_delivered_unchanged(self):
+        self.puanlar = [{'ret': 0.0, 'sart': 0.0, 'bitmedi': 0.1}]
+        out = self.calistir(sse('Tamam, test ciktisi: 3 passed.'))
+        self.assertEqual(self.devamlar, [])
+        self.assertIn(b'3 passed', out)
+
+    def test_a_refusal_still_goes_down_the_chain_not_back(self):
+        self.puanlar = [{'ret': 0.9, 'sart': 0.0, 'bitmedi': 0.9}]
+        ac = Mock(return_value=(Yanit(sse('katman')), None, '[K1]'))
+        self.h._denetimli_akis(Yanit(sse('Yapamam.')), '[1]', None, None, 'yap', ['Katman-1'], ac, hedef='Ajan', devam=self.devam)
+        self.assertEqual(self.devamlar, [])
+        ac.assert_called_once_with('Katman-1')
+
+    def test_a_failed_retry_delivers_the_first_answer(self):
+        self.puanlar = [{'ret': 0.0, 'sart': 0.0, 'bitmedi': 0.9}]
+
+        def bozuk(ad, onceki):
+            raise OSError('acilamadi')
+        self.h._denetimli_akis(Yanit(sse('Bitti.')), '[1]', None, None, 'yap', [], Mock(), hedef='Ajan', devam=bozuk)
+        self.assertIn(b'Bitti.', self.gonderilen())
+
+    def test_a_broken_or_refused_retry_delivers_the_approved_first_answer(self):
+        for ikinci in (sse(), sse('Yapamam.')):
+            with self.subTest(ikinci=ikinci[:40]):
+                self.setUp()
+                self.puanlar = [{'ret': 0.0, 'sart': 0.0, 'bitmedi': 0.9}, {'ret': 0.9, 'sart': 0.0}]
+                ac = Mock(return_value=(Yanit(sse('katman')), None, '[K1]'))
+                self.h._denetimli_akis(Yanit(sse('Ilk cevap.')), '[1]', None, None, 'yap', ['Katman-1'], ac,
+                                       hedef='Ajan', devam=lambda ad, onceki: (Yanit(ikinci), None, '[devam]'))
+                self.assertIn(b'Ilk cevap.', self.gonderilen())
+                ac.assert_not_called()
+
+    def test_without_the_stage_the_finish_question_is_not_sent(self):
+        govdeler = []
+
+        def gonder(govde, key):
+            govdeler.append(govde)
+            return {'answers': {'ret': {'noul': 0.1}, 'sart': {'noul': 0.1}}}
+        puan = jev_denetim.sor('i', 'c', 'k', gonder=gonder)
+        self.assertNotIn('bitmedi', govdeler[0]['questions'])
+        self.assertNotIn('bitmedi', puan)
+        puan = jev_denetim.sor('i', 'c', 'k', gonder=gonder, bitis=True)
+        self.assertIn('bitmedi', govdeler[1]['questions'])
+        self.assertEqual(set(puan), {'ret', 'sart'})                 # unanswered extra question: main verdict stands
+        self.assertFalse(jev_denetim.bitmedi_mi(puan))
+
+
+
+class DogrulayiciElemesi(Ev):
+    def test_off_by_default_and_asked_only_when_enabled(self):
+        import io as _io
+        import karar_sor
+        self.save()
+        out = _io.StringIO()
+        self.assertEqual(karar_sor.main(['dogrulayici'], _io.StringIO('{"user_request": "x", "assistant_reply": "kabul"}'), out), 0)
+        self.assertEqual(json.loads(out.getvalue())['enabled'], False)
+        self.settings['verifierCheck']['enabled'] = True
+        self.save()
+        govdeler = []
+
+        def gonder(govde, key):
+            govdeler.append(govde)
+            return {'answers': {'kanitsiz': {'noul': 0.92}}}
+        sonuc = karar_sor.dogrulayici({'user_request': 'olcut', 'assistant_reply': '{"karar":"kabul","bulgular":[]}'}, 'k', gonder)
+        self.assertEqual((sonuc['enabled'], sonuc['kanitsiz'], sonuc['puan']), (True, True, 0.92))
+        self.assertEqual(set(govdeler[0]['questions']), {'kanitsiz'})
+        bozuk = karar_sor.dogrulayici({'user_request': 'o', 'assistant_reply': 'r'}, 'k', Mock(side_effect=OSError('yok')))
+        self.assertIsNone(bozuk['kanitsiz'])
+
+    def test_wrong_usage_exits_2(self):
+        import io as _io
+        import karar_sor
+        self.assertEqual(karar_sor.main(['baska'], _io.StringIO('{}'), _io.StringIO()), 2)
+
+
+class Inceleme(Ev):
+    def test_the_correction_channel_needs_an_always_pass_target_while_checks_are_on(self):
+        self.settings['watchModels'] = ['Chat-Model', 'Ajan']
+        self.save()
+        self.assertTrue(jev_denetim.izleme_mi('Chat-Model'))
+        self.assertFalse(jev_denetim.izleme_mi('Ajan'))               # checked target: no sideband
+        self.settings['enabled'] = False
+        self.save()
+        self.assertTrue(jev_denetim.izleme_mi('Ajan'))
+
+    def test_a_turn_start_question_does_not_wait_in_the_queue_beyond_its_timeout(self):
+        self.settings['maxConcurrent'] = 1
+        self.settings['queueWaitSeconds'] = 3600
+        self.save()
+        s = jev_settings.read()[0]
+        self.assertTrue(jev_settings.acquire(s))                     # the only slot is taken
+        try:
+            t0 = time.monotonic()
+            self.assertIsNone(jev_denetim.sorular({'user_request': 'x'}, {'zor': 'q'}, 'k', 1, gonder=lambda g, k: {}))
+            self.assertLess(time.monotonic() - t0, 3)
+        finally:
+            jev_settings.release()
+
+    def test_the_prefilter_target_cannot_be_the_automatic_model(self):
+        self.settings['prefilter']['target'] = self.settings['autoRoute']['model']
+        self.save()
+        with self.assertRaises(ValueError):
+            jev_settings.read()
+
+    def test_dify_redirects_are_refused_so_the_key_never_moves(self):
+        import urllib.error
+        with self.assertRaises(urllib.error.HTTPError):
+            karar_politikasi._YonlendirmeYok().redirect_request(
+                Mock(full_url='https://dify.example/v1/workflows/run'), None, 302, 'Found', {}, 'http://evil.example/')
+
+
+class IzlemeSuzgeci(unittest.TestCase):
+    def test_a_huge_frame_passes_through_instead_of_breaking_the_stream(self):
+        tree_sinif = next(n for n in TREE.body if isinstance(n, ast.ClassDef) and n.name == 'WatchResponse')
+        from bekci_watch import MetadataFilter
+        logs = []
+        env = {'MetadataFilter': MetadataFilter, 'log': logs.append}
+        exec(compile(ast.Module(body=[tree_sinif], type_ignores=[]), 'kopru.py', 'exec'), env)
+        buyuk = b'data: ' + b'x' * 300000
+        parcalar = [buyuk[:200000], buyuk[200000:], b'\n\n', b'']
+
+        class Ham:
+            def read1(self, n):
+                return parcalar.pop(0)
+        w = env['WatchResponse'](Ham(), lambda m: None)
+        cikti = b''
+        while True:
+            b = w.read1(65536)
+            if not b and w.done or not parcalar and not b:
+                break
+            cikti += b
+        self.assertIn(b'x' * 1000, cikti)
+        self.assertEqual(cikti.count(b'x'), 300000)
+        self.assertTrue(logs)
+
+
+if __name__ == '__main__':
+    unittest.main()

apps/desktop/assets/codex-bridge/test_live_limits.py

@@ -0,0 +1,18 @@
+import pencere
+
+
+def test_exact_combo_limits_override_unknown_and_local_defaults():
+    row = {"context_length": 872000, "max_input_tokens": 872000, "max_output_tokens": 128000}
+    result = pencere.coz("GPT-6-Astra", "combo", None, ilan=row)
+    assert result["pencere"] == 872000
+    assert result["kaynak"] == "saglayici-katalogu"
+    result = pencere.coz("codex-gpt-6-astra", "model", "codex/gpt-6-astra", ilan=row)
+    assert result["pencere"] == 872000
+
+
+def test_learned_actual_limit_still_wins_and_invalid_metadata_is_ignored():
+    result = pencere.coz("combo", "combo", None, ilan={"context_length": 872000}, ogr={"combo": 500000})
+    assert result["pencere"] == 500000 and result["kaynak"] == "ogrenilen"
+    for value in (True, -1, "872000", 999999999):
+        result = pencere.coz("combo", "combo", None, ilan={"context_length": value})
+        assert result["pencere"] == pencere.VARSAYILAN

apps/desktop/assets/codex-bridge/test_native_switch_regression.py

@@ -0,0 +1,83 @@
+"""Native switch regressions using the real HTTP splitter and offline peers."""
+import copy
+import gzip
+import json
+import unittest
+import ast
+from pathlib import Path
+
+import bridge
+import gecis_context as gc
+import ozet_kopru
+import test_ayirici as fixtures
+
+
+class NativeSwitch(unittest.TestCase):
+    setUp = fixtures.Ayirici.setUp
+    tearDown = fixtures.Ayirici.tearDown
+    iste = fixtures.Ayirici.iste
+
+    def test_unknown_native_capacity_is_not_invented(self):
+        tree = ast.parse(Path(__file__).with_name('kopru.py').read_text(encoding='utf-8'))
+        method = next(node for node in ast.walk(tree)
+                      if isinstance(node, ast.FunctionDef) and node.name == '_transfer_window')
+        ns = {'ek_model_mu': lambda _: False, 'LAST_MODELS': {}, 'gecis_context': gc, 'json': json}
+        exec(compile(ast.Module(body=[method], type_ignores=[]), 'window', 'exec'), ns)
+        from types import SimpleNamespace
+        with self.assertRaises(gc.TransferError):
+            ns['_transfer_window'](SimpleNamespace(headers={}), 'gpt-6-astra')
+
+    def test_opaque_native_switch_with_persisted_foreign_residue(self):
+        self.ozgun.cevap = fixtures.duz(200, b'data: {"type":"response.completed"}\n\n', 'text/event-stream')
+        compact = {'type': 'compaction', 'id': 'cmp_native',
+                   'encrypted_content': 'gAAAAABp' + 'AqZ09_-jX' * 10000}
+        req = {'model': 'gpt-6.1-sol', 'prompt_cache_key': 'restart', 'input': [
+            ozet_kopru.ozet_ogesi('DECISION-4827 must survive'), compact,
+            {'type': 'custom_tool_call', 'id': 'fc_123', 'call_id': 'call_123',
+             'name': 'apply_patch', 'input': 'patch text'},
+            {'type': 'custom_tool_call_output', 'id': 'fco_123',
+             'call_id': 'call_123', 'output': 'complete'},
+            {'role': 'user', 'content': 'continue'}]}
+        before = copy.deepcopy(req)
+        for cold, model in ((True, 'gpt-6.1-sol'), (False, 'gpt-6-astra'), (True, 'gpt-6-astra')):
+            if cold:
+                bridge.TRANSFERS.clear()
+            req['model'] = model
+            body = gzip.compress(json.dumps(req).encode())
+            self.assertEqual(self.iste('POST', '/backend-api/codex/responses', body,
+                                     {'Content-Encoding': 'gzip'})[0], 200)
+            sent = json.loads(self.ozgun.gelen[-1]['govde'])
+            self.assertEqual(sent['input'][1], compact)
+            self.assertEqual(sent['input'][2]['id'], 'ctc_123')
+            self.assertEqual(sent['input'][3]['id'], 'ctco_123')
+            self.assertEqual(sent['input'][3]['call_id'], 'call_123')
+            self.assertIn('DECISION-4827', json.dumps(sent))
+            self.assertEqual(self.kopru.gelen, [])
+        self.assertEqual(req['input'], before['input'])
+
+    def test_clean_native_body_is_byte_identical_even_after_external_source(self):
+        req = {'model': 'ide/test', 'prompt_cache_key': 'return', 'input': []}
+        self.iste('POST', '/backend-api/codex/responses', json.dumps(req).encode())
+        self.kopru.gelen.clear()
+        req.update(model='gpt-6-astra', input=[{'type': 'compaction',
+                   'encrypted_content': 'gAAAAABp' + 'X' * 100000}])
+        raw = gzip.compress(json.dumps(req, indent=3).encode())
+        self.iste('POST', '/backend-api/codex/responses', raw, {'Content-Encoding': 'gzip'})
+        self.assertEqual(self.ozgun.gelen[-1]['govde'], raw)
+        self.assertEqual(self.kopru.gelen, [])
+
+    def test_cold_native_tool_id_repair_does_not_require_semantic_budget(self):
+        req = {'model': 'gpt-6-astra', 'input': [
+            {'type': 'custom_tool_call', 'id': 'fc_old', 'call_id': 'call_old',
+             'name': 'apply_patch', 'input': 'x' * 100000},
+            {'type': 'custom_tool_call_output', 'id': 'fco_old',
+             'call_id': 'call_old', 'output': 'complete'}]}
+        self.iste('POST', '/backend-api/codex/responses', json.dumps(req).encode())
+        self.assertEqual(len(self.kopru.gelen), 0)
+        sent = json.loads(self.ozgun.gelen[-1]['govde'])
+        self.assertEqual(sent, gc.normalize(req))
+        self.assertEqual(req['input'][0]['id'], 'fc_old')
+
+
+if __name__ == '__main__':
+    unittest.main()

apps/desktop/assets/codex-bridge/test_terminal_stream.py

@@ -0,0 +1,143 @@
+"""Real-socket regressions for terminal worker errors (no provider calls)."""
+import json
+import unittest
+
+import test_ayirici as fixtures
+import terminal_stream
+
+
+ERROR = b'event: error\ndata: {"type":"error","error":{"type":"upstream_error","message":"upstream 503"}}\n\n'
+COMPLETE = b'event: response.completed\ndata: {"type":"response.completed","response":{"id":"resp_ok","status":"completed","output":[]}}\n\n'
+
+
+class TerminalStream(unittest.TestCase):
+    setUp = fixtures.Ayirici.setUp
+    tearDown = fixtures.Ayirici.tearDown
+    iste = fixtures.Ayirici.iste
+
+    def request(self, token="a", text="check"):
+        body = json.dumps({"model": "ide/test", "input": [{"role": "user", "content": text}]})
+        return self.iste("POST", "/backend-api/codex/responses", body,
+                         {"Authorization": "Bearer " + token})
+
+    def worker(self, payload):
+        def respond(h, body):
+            if h.path.endswith("/prepare-transfer"):
+                return fixtures.duz(200, json.dumps({"request": json.loads(body)["request"]}).encode())(h, body)
+            return fixtures.duz(200, payload, "text/event-stream")(h, body)
+        self.kopru.cevap = respond
+
+    def inference_count(self):
+        return sum(x["yol"].endswith("/responses") for x in self.kopru.gelen)
+
+    def test_error_only_stream_is_an_honest_http_failure(self):
+        self.worker(ERROR)
+        status, body, _ = self.request()
+        self.assertEqual(status, 400)
+        self.assertIn("upstream 503", json.loads(body)["error"]["message"])
+        self.assertNotIn(b"response.completed", body)
+        self.assertEqual(self.inference_count(), 1)
+
+    def test_error_after_heartbeat_stops_automatic_replay_once(self):
+        def respond(h, body):
+            if h.path.endswith("/prepare-transfer"):
+                return fixtures.duz(200, json.dumps({"request": json.loads(body)["request"]}).encode())(h, body)
+            h.send_response(200)
+            h.send_header("Content-Type", "text/event-stream")
+            h.send_header("Transfer-Encoding", "chunked")
+            h.end_headers()
+            for chunk in (b": keepalive\n\n", ERROR):
+                h.wfile.write(b"%x\r\n" % len(chunk) + chunk + b"\r\n")
+                h.wfile.flush()
+                fixtures.time.sleep(.08)
+            h.wfile.write(b"0\r\n\r\n")
+        self.kopru.cevap = respond
+        status, body, _ = self.request()
+        self.assertEqual((status, body), (200, b": keepalive\n\n" + ERROR))
+        status, body, _ = self.request()
+        self.assertEqual(status, 400)
+        self.assertIn(b"upstream 503", body)
+        self.assertEqual(self.inference_count(), 1)
+        # A later explicit retry is allowed; the one-shot guard is consumed.
+        self.worker(COMPLETE)
+        self.assertEqual(self.request()[:2], (200, COMPLETE))
+        self.assertEqual(self.inference_count(), 2)
+
+    def test_native_error_stream_is_not_intercepted(self):
+        self.ozgun.cevap = fixtures.duz(200, ERROR, "text/event-stream")
+        body = json.dumps({"model": "gpt-6-astra", "input": []})
+        self.assertEqual(self.iste("POST", "/backend-api/codex/responses", body)[:2], (200, ERROR))
+
+    def test_success_stream_is_byte_identical(self):
+        self.worker(COMPLETE)
+        self.assertEqual(self.request()[:2], (200, COMPLETE))
+        self.assertEqual(self.request()[:2], (200, COMPLETE))
+        self.assertEqual(self.inference_count(), 2)
+
+    def test_eof_without_upstream_error_keeps_network_retry(self):
+        self.worker(b": keepalive\n\n")
+        self.assertEqual(self.request()[0], 200)
+        self.assertEqual(self.request()[0], 200)
+        self.assertEqual(self.inference_count(), 2)
+
+    def test_worker_exhausted_failure_is_terminal_without_changing_its_reason(self):
+        self.worker(b'event: response.failed\ndata: {"type":"response.failed","response":{"status":"failed","error":{"code":"jev_no_fallback","message":"No accepted response"}}}\n\n')
+        status, body, _ = self.request()
+        self.assertEqual(status, 400)
+        self.assertEqual(json.loads(body)["error"]["code"], "jev_no_fallback")
+
+    def test_existing_context_error_classification_is_preserved(self):
+        data = b'event: response.failed\ndata: {"type":"response.failed","response":{"error":{"code":"context_length_exceeded","message":"Context full"}}}\n\n'
+        self.worker(data)
+        self.assertEqual(self.request()[:2], (200, data))
+
+
+class ObserverTests(unittest.TestCase):
+    def test_fragmented_crlf_and_multiline_json(self):
+        data = b'event: error\r\ndata: {"type":"error",\r\ndata: "error":{"type":"upstream_error","message":"503"}}\r\n\r\n'
+        observer = terminal_stream.Observer()
+        for byte in data:
+            observer.feed(bytes([byte]))
+        self.assertEqual(observer.error['message'], '503')
+
+    def test_large_and_malformed_frames_are_bounded_and_do_not_crash(self):
+        observer = terminal_stream.Observer()
+        observer.feed(b'data: ' + b'x'*200000)
+        self.assertLessEqual(len(observer.tail), observer.LIMIT)
+        observer.feed(b'\n\ndata: {"response":[]}\n\n' + ERROR)
+        self.assertEqual(observer.error['message'], 'upstream 503')
+
+    def test_completed_stream_does_not_poison_next_request(self):
+        observer = terminal_stream.Observer()
+        observer.feed(ERROR + COMPLETE)
+        self.assertIsNone(observer.error)
+        self.assertTrue(observer.completed)
+
+    def test_one_shot_expiry_and_capacity(self):
+        now = [10]
+        cache = terminal_stream.FailureReplays(ttl=5, capacity=2, clock=lambda: now[0])
+        cache.remember(b'a', {'code': 'a'})
+        self.assertEqual(cache.take(b'a'), {'code': 'a'})
+        self.assertIsNone(cache.take(b'a'))
+        cache.remember(b'a', {})
+        now[0] = 16
+        self.assertIsNone(cache.take(b'a'))
+        for key in (b'a', b'b', b'c'):
+            cache.remember(key, {'code': 'error'})
+        self.assertIsNone(cache.take(b'a'))
+        self.assertEqual(len(cache.items), 2)
+
+    def test_request_identity_separates_accounts_sessions_models_and_inputs(self):
+        base = {'model': 'ide/a', 'input': []}
+        headers = {'Authorization': 'Bearer a', 'session_id': 'one'}
+        key = terminal_stream.request_key(base, headers)
+        self.assertEqual(key, terminal_stream.request_key(dict(reversed(list(base.items()))), headers))
+        for request, other in [({'model': 'ide/b', 'input': []}, headers),
+                               ({'model': 'ide/a', 'input': ['next']}, headers),
+                               (base, dict(headers, Authorization='Bearer b')),
+                               (base, dict(headers, session_id='two'))]:
+            self.assertNotEqual(key, terminal_stream.request_key(request, other))
+
+
+if __name__ == "__main__":
+    unittest.main()

apps/desktop/electron/codex-link-config.test.ts

@@ -225,12 +225,17 @@ describe('preference file', () => {
   })
 
   it('writes the contract shape and keeps unknown fields', () => {
-    expect(JSON.parse(serializeCodexLinkSettings({}, false))).toEqual({ enabled: false, kapsam: 'ide' })
+    expect(JSON.parse(serializeCodexLinkSettings({}, false))).toEqual({
+      enabled: false,
+      mod: 'dogrudan',
+      kapsam: 'ide'
+    })
 
     const { stored } = parseCodexLinkSettings('{"enabled": false, "kapsam": "hepsi", "gelecek": {"a": 1}}')
 
     expect(JSON.parse(serializeCodexLinkSettings(stored, true))).toEqual({
       enabled: true,
+      mod: 'dogrudan',
       gelecek: { a: 1 },
       kapsam: 'hepsi'
     })
@@ -308,3 +313,17 @@ describe('bridge configuration and command', () => {
     expect(codexAutostartPlan(`${deep}\\pythonw.exe`, launch, `${deep}\\baslat.pyw`)).toBeNull()
   })
 })
+
+describe('mode preference', () => {
+  it('uses direct for missing, invalid and malformed modes', () => {
+    for (const raw of [null, '{', '{}', '{"mod":"bad"}', '{"mod":false}']) {
+      expect(parseCodexLinkSettings(raw).mod).toBe('dogrudan')
+    }
+    expect(parseCodexLinkSettings('{"mod":"aiturk"}').mod).toBe('aiturk')
+  })
+  it('preserves other fields when changing mode', () => {
+    const stored = { enabled: false, mod: 'aiturk', kapsam: 'hepsi', future: { a: 1 } }
+    expect(JSON.parse(serializeCodexLinkSettings(stored, false, 'dogrudan'))).toEqual({ ...stored, mod: 'dogrudan' })
+    expect(JSON.parse(serializeCodexLinkSettings(stored, true)).mod).toBe('aiturk')
+  })
+})

apps/desktop/electron/codex-link-config.ts

@@ -27,7 +27,7 @@ export const CODEX_LINK_REFRESH_URL = `${CODEX_LINK_ORIGIN}/aiturk/codex-baglama
 export const CODEX_LINK_MARKER = '# AITURK IDE Codex Baglama'
 // Must equal SURUM in assets/codex-bridge/bridge.py; a running bridge that reports
 // another version is restarted so an updated IDE never keeps an old bridge alive.
-export const CODEX_BRIDGE_VERSION = '14'
+export const CODEX_BRIDGE_VERSION = '19'
 export const CODEX_LINK_LINE = `openai_base_url = "${CODEX_LINK_ORIGIN}/backend-api/codex"  ${CODEX_LINK_MARKER}`
 
 export const CODEX_LINK_RUN_KEY = 'HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run'
@@ -300,6 +300,7 @@ export function removeCodexLinkLine(source: string): CodexConfigEdit {
 
 export interface CodexLinkSettings {
   enabled: boolean
+  mod: 'dogrudan' | 'aiturk'
   /** Every field of the stored object, so a rewrite keeps what it did not set. */
   stored: Record<string, unknown>
 }
@@ -307,26 +308,34 @@ export interface CodexLinkSettings {
 /** Missing, unreadable or malformed means ON: the feature is on by default. */
 export function parseCodexLinkSettings(raw: null | string | undefined): CodexLinkSettings {
   if (typeof raw !== 'string') {
-    return { enabled: true, stored: {} }
+    return { enabled: true, mod: 'dogrudan', stored: {} }
   }
 
   try {
     const parsed = JSON.parse(raw)
 
     if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-      return { enabled: true, stored: {} }
+      return { enabled: true, mod: 'dogrudan', stored: {} }
     }
 
-    return { enabled: parsed.enabled !== false, stored: parsed as Record<string, unknown> }
+    return {
+      enabled: parsed.enabled !== false,
+      mod: parsed.mod === 'aiturk' ? 'aiturk' : 'dogrudan',
+      stored: parsed as Record<string, unknown>
+    }
   } catch {
-    return { enabled: true, stored: {} }
+    return { enabled: true, mod: 'dogrudan', stored: {} }
   }
 }
 
-export function serializeCodexLinkSettings(stored: Record<string, unknown>, enabled: boolean): string {
+export function serializeCodexLinkSettings(
+  stored: Record<string, unknown>,
+  enabled: boolean,
+  mod: 'dogrudan' | 'aiturk' = stored.mod === 'aiturk' ? 'aiturk' : 'dogrudan'
+): string {
   const kapsam = typeof stored.kapsam === 'string' && stored.kapsam ? stored.kapsam : 'ide'
 
-  return `${JSON.stringify({ ...stored, enabled, kapsam }, null, 2)}\n`
+  return `${JSON.stringify({ ...stored, enabled, mod, kapsam }, null, 2)}\n`
 }
 
 // ── Bridge configuration ────────────────────────────────────────────────────

apps/desktop/electron/codex-link-types.ts

@@ -5,6 +5,8 @@
  * code into its program. See codex-link.ts for what the fields mean in action.
  */
 
+export type CodexLinkMode = 'dogrudan' | 'aiturk'
+
 export type CodexLinkIdeState = 'anahtar-yok' | 'kapali' | 'tamam'
 
 /** Stable codes; the renderer owns the wording. Detail goes to the desktop log. */
@@ -18,6 +20,7 @@ export type CodexLinkError =
 
 export interface CodexLinkStatus {
   enabled: boolean
+  mod: CodexLinkMode
   /** Codex's `config.toml` exists on this machine. */
   codexFound: boolean
   /** The IDE's own Python environment exists (first-run setup finished). */
@@ -34,6 +37,7 @@ export interface CodexLinkStatus {
 
 export interface CodexLinkPatch {
   enabled?: boolean
+  mod?: CodexLinkMode
   /** "Sync now": re-run the apply without changing the preference. */
   sync?: boolean
 }

apps/desktop/electron/codex-link.test.ts

@@ -52,6 +52,7 @@ function createWorld(patch: Partial<World> & { files?: Map<string, string> } = {
     events: [],
     files: new Map([
       [PATHS.codexConfig, USER_CONFIG],
+      [PATHS.settingsFile, JSON.stringify({ enabled: true, mod: 'aiturk' })],
       [PATHS.bridgeScript, '# bridge'],
       [PATHS.pythonw, ''],
       [PATHS.python, '']
@@ -192,6 +193,7 @@ describe('applyCodexLink', () => {
 
     expect(status).toEqual({
       enabled: true,
+      mod: 'aiturk',
       codexFound: true,
       venvReady: true,
       foreign: false,
@@ -328,7 +330,11 @@ describe('applyCodexLink', () => {
       'autostart clear',
       'stop'
     ])
-    expect(JSON.parse(world.files.get(PATHS.settingsFile) ?? '')).toEqual({ enabled: false, kapsam: 'ide' })
+    expect(JSON.parse(world.files.get(PATHS.settingsFile) ?? '')).toEqual({
+      enabled: false,
+      mod: 'aiturk',
+      kapsam: 'ide'
+    })
     // Byte for byte what the user had before the feature touched it.
     expect(world.files.get(PATHS.codexConfig)).toBe(USER_CONFIG)
     expect(world.autostart).toBeNull()
@@ -344,7 +350,8 @@ describe('applyCodexLink', () => {
     world.configWriteFails = true
 
     expect(await link.apply({ enabled: false })).toMatchObject({
-      bridgeRunning: true, lastError: 'config-write-failed'
+      bridgeRunning: true,
+      lastError: 'config-write-failed'
     })
     expect(world.files.get(PATHS.codexConfig)).toBe(linkedConfig)
     expect(world.autostart).toBe(autostart)
@@ -358,7 +365,7 @@ describe('applyCodexLink', () => {
 
   it('stays off across applies and comes back when turned on', async () => {
     const { link, world } = createWorld()
-    world.files.set(PATHS.settingsFile, '{"enabled": false, "kapsam": "ide", "not": "ours"}')
+    world.files.set(PATHS.settingsFile, '{"enabled": false, "mod": "aiturk", "kapsam": "ide", "not": "ours"}')
 
     expect(await link.apply()).toMatchObject({ enabled: false, bridgeRunning: false })
     expect(spawns(world)).toEqual([])
@@ -367,6 +374,7 @@ describe('applyCodexLink', () => {
     expect(await link.apply({ enabled: true })).toMatchObject({ enabled: true, bridgeRunning: true })
     expect(JSON.parse(world.files.get(PATHS.settingsFile) ?? '')).toEqual({
       enabled: true,
+      mod: 'aiturk',
       kapsam: 'ide',
       not: 'ours'
     })
@@ -424,3 +432,44 @@ describe('getStatus', () => {
     expect(effects(world)).toEqual([])
   })
 })
+
+describe('connection mode', () => {
+  it('defaults to direct, starts bridge and autostart without writing a line', async () => {
+    const { link, world } = createWorld()
+    world.files.delete(PATHS.settingsFile)
+    expect(await link.apply()).toMatchObject({ mod: 'dogrudan', bridgeRunning: true })
+    expect(world.files.get(PATHS.codexConfig)).toBe(USER_CONFIG)
+    expect(spawns(world)).toHaveLength(1)
+    expect(world.autostart).not.toBeNull()
+  })
+  it('removes the old line and preserves the current bridge in direct mode', async () => {
+    const { link, world } = createWorld({ listening: true })
+    world.files.set(PATHS.settingsFile, '{"mod":"dogrudan"}')
+    world.files.set(PATHS.codexConfig, `${CODEX_LINK_LINE}\r\n${USER_CONFIG}`)
+    await link.apply()
+    expect(world.files.get(PATHS.codexConfig)).toBe(USER_CONFIG)
+    expect(spawns(world)).toHaveLength(0)
+    expect(world.events).not.toContain('stop')
+    expect(world.autostart).not.toBeNull()
+  })
+  it('switches both ways, persists mode and preserves unrelated preferences', async () => {
+    const { link, world } = createWorld({ listening: true })
+    world.files.set(PATHS.settingsFile, '{"mod":"dogrudan","custom":{"keep":1}}')
+    await link.apply({ mod: 'aiturk' })
+    expect(world.files.get(PATHS.codexConfig)).toContain(CODEX_LINK_LINE)
+    await link.apply({ mod: 'dogrudan' })
+    expect(world.files.get(PATHS.codexConfig)).toBe(USER_CONFIG)
+    expect(JSON.parse(world.files.get(PATHS.settingsFile)!)).toMatchObject({ mod: 'dogrudan', custom: { keep: 1 } })
+    await link.apply()
+    expect(world.files.get(PATHS.codexConfig)).toBe(USER_CONFIG)
+    expect(world.events).not.toContain('stop')
+  })
+  it.each(['dogrudan', 'aiturk'] as const)('preserves foreign URL in %s', async mod => {
+    const { link, world } = createWorld()
+    const foreign = 'openai_base_url = "https://other.example"\n'
+    world.files.set(PATHS.codexConfig, foreign)
+    await link.apply({ mod })
+    expect(world.files.get(PATHS.codexConfig)).toBe(foreign)
+    expect(spawns(world)).toHaveLength(0)
+  })
+})

apps/desktop/electron/codex-link.ts

@@ -186,6 +186,7 @@ export function createCodexLink(deps: CodexLinkDeps): CodexLink {
     bridge: BridgeProbe
   ): CodexLinkStatus => ({
     enabled,
+    mod: readSettings().mod,
     codexFound: config.found,
     venvReady: interpreter() !== null,
     foreign: config.owner === 'foreign',
@@ -329,7 +330,8 @@ export function createCodexLink(deps: CodexLinkDeps): CodexLink {
       return bridge
     }
 
-    const edit = addCodexLinkLine(config.text ?? '')
+    const edit =
+      readSettings().mod === 'aiturk' ? addCodexLinkLine(config.text ?? '') : removeCodexLinkLine(config.text ?? '')
 
     if (edit.changed) {
       try {
@@ -364,9 +366,16 @@ export function createCodexLink(deps: CodexLinkDeps): CodexLink {
   const run = async (patch?: CodexLinkPatch): Promise<CodexLinkStatus> => {
     lastError = null
 
-    if (typeof patch?.enabled === 'boolean') {
+    if (typeof patch?.enabled === 'boolean' || patch?.mod === 'aiturk' || patch?.mod === 'dogrudan') {
       try {
-        deps.writeTextAtomic(paths.settingsFile, serializeCodexLinkSettings(readSettings().stored, patch.enabled))
+        deps.writeTextAtomic(
+          paths.settingsFile,
+          serializeCodexLinkSettings(
+            readSettings().stored,
+            patch?.enabled ?? readSettings().enabled,
+            patch?.mod ?? readSettings().mod
+          )
+        )
       } catch (error) {
         // The preference did not stick, so do not act on it either: what the
         // machine does must match what the file says after a restart.

apps/desktop/electron/main.ts

@@ -17318,6 +17318,7 @@ ipcMain.handle('aiturk:codex-link:set', async (event, patch) => {
 
   return codexLink.apply({
     enabled: typeof patch?.enabled === 'boolean' ? patch.enabled : undefined,
+    mod: patch?.mod === 'aiturk' || patch?.mod === 'dogrudan' ? patch.mod : undefined,
     sync: patch?.sync === true
   })
 })

apps/desktop/electron/staged-transition-types.ts

@@ -12,11 +12,35 @@ export interface StagedTransitionSettings {
   maxConcurrent: number
   queueWaitSeconds: number
   failureAction: 'pass' | 'next'
+  // Schema 2 (14 Oct 2026). A schema 1 file gets these from the defaults; every stage starts disabled.
+  watchModels: string[]
+  prefilter: { enabled: boolean; question: string; threshold: number; target: string; timeoutSeconds: number }
+  autoRoute: {
+    enabled: boolean
+    model: string
+    timeoutSeconds: number
+    questions: { zor: string; arastirma: string }
+    thresholds: { zor: number; arastirma: number }
+    targets: { basit: string; zor: string; arastirma: string }
+  }
+  finishCheck: { enabled: boolean; question: string; threshold: number; note: string }
+  verifierCheck: { enabled: boolean; question: string; threshold: number }
+  policy: { source: 'local' | 'dify'; endpoint: string; refreshMinutes: number }
+}
+
+export interface StagedTransitionPolicyStatus {
+  fetchedAt?: string
+  lastGoodAt?: string
+  ok: boolean
+  error?: string
+  sections: string[]
 }
 
 export interface StagedTransitionState {
   settings: StagedTransitionSettings
   keyConfigured: boolean
+  policyKeyConfigured?: boolean
+  policyStatus?: StagedTransitionPolicyStatus | null
   models?: { id: string; name: string }[]
   modelsAvailable?: boolean
 }
@@ -24,4 +48,5 @@ export interface StagedTransitionState {
 export interface StagedTransitionPatch {
   settings: StagedTransitionSettings
   apiKey?: string
+  policyApiKey?: string
 }

apps/desktop/electron/staged-transition.test.ts

@@ -4,7 +4,12 @@ import path from 'node:path'
 
 import { afterEach, describe, expect, it } from 'vitest'
 
-import { createStagedTransitionStore, stagedTransitionDefaults, validateStagedTransition } from './staged-transition'
+import {
+  createStagedTransitionStore,
+  readPolicyStatus,
+  stagedTransitionDefaults,
+  validateStagedTransition
+} from './staged-transition'
 
 const dirs: string[] = []
 afterEach(() => {
@@ -50,4 +55,63 @@ describe('staged transition settings', () => {
     expect(() => validateStagedTransition({ ...before.settings, thresholds: { ret: NaN, sart: 0.7 } })).toThrow()
     expect(() => validateStagedTransition({ ...before.settings, endpoint: 'http://example.com' })).toThrow()
   })
+  it('loads a schema 1 file with every new stage disabled and keeps unknown-free output', () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'jev-settings-test-'))
+    dirs.push(dir)
+    const old = structuredClone(stagedTransitionDefaults) as unknown as Record<string, unknown>
+
+    for (const key of ['watchModels', 'prefilter', 'autoRoute', 'finishCheck', 'verifierCheck', 'policy']) {
+      delete old[key]
+    }
+    fs.writeFileSync(path.join(dir, 'jev-settings.json'), JSON.stringify({ settings: old, protectedKey: 'k' }))
+    const store = createStagedTransitionStore(dir, path.join(dir, 'missing.env'), x => x)
+    const state = store.get()
+    expect(state.settings.prefilter.enabled).toBe(false)
+    expect(state.settings.autoRoute.enabled).toBe(false)
+    expect(state.settings.finishCheck.enabled).toBe(false)
+    expect(state.settings.verifierCheck.enabled).toBe(false)
+    expect(state.settings.policy.source).toBe('local')
+    expect(state.keyConfigured).toBe(true)
+    const partial = { ...structuredClone(stagedTransitionDefaults), prefilter: { enabled: true, threshold: 0.8 } }
+    const filled = validateStagedTransition(partial)
+    expect(filled.prefilter.enabled).toBe(true)
+    expect(filled.prefilter.threshold).toBe(0.8)
+    expect(filled.prefilter.target).toBe(stagedTransitionDefaults.prefilter.target)
+  })
+  it('keeps the Dify key protected and reports the last rules fetch', () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'jev-settings-test-'))
+    dirs.push(dir)
+    const store = createStagedTransitionStore(dir, path.join(dir, 'missing.env'), () => 'protected-value')
+    const settings = { ...structuredClone(stagedTransitionDefaults), policy: { ...stagedTransitionDefaults.policy, source: 'dify' as const } }
+    const saved = store.save({ settings, policyApiKey: 'app-dummy-secret' })
+    expect(saved.policyKeyConfigured).toBe(true)
+    expect(fs.readFileSync(path.join(dir, 'jev-settings.json'), 'utf8')).not.toContain('app-dummy-secret')
+    expect(store.save({ settings }).policyKeyConfigured).toBe(true)
+    expect(store.save({ settings, policyApiKey: '' }).policyKeyConfigured).toBe(false)
+    expect(readPolicyStatus(dir)).toBeNull()
+    fs.writeFileSync(
+      path.join(dir, 'jev-policy.json'),
+      JSON.stringify({ fetchedAt: 'now', ok: true, error: 'Dify down', overrides: { autoRoute: { enabled: true } } })
+    )
+    expect(store.get().policyStatus).toEqual({ fetchedAt: 'now', lastGoodAt: undefined, ok: true, error: 'Dify down', sections: ['autoRoute'] })
+  })
+  it('rejects invalid decision stage values', () => {
+    const base = structuredClone(stagedTransitionDefaults)
+    expect(() => validateStagedTransition({ ...base, prefilter: { ...base.prefilter, threshold: 2 } })).toThrow()
+    expect(() => validateStagedTransition({ ...base, prefilter: { ...base.prefilter, timeoutSeconds: 0 } })).toThrow()
+    expect(() =>
+      validateStagedTransition({ ...base, autoRoute: { ...base.autoRoute, targets: { ...base.autoRoute.targets, zor: 'Otomatik' } } })
+    ).toThrow()
+    expect(() => validateStagedTransition({ ...base, finishCheck: { ...base.finishCheck, note: '' } })).toThrow()
+    expect(() => validateStagedTransition({ ...base, policy: { ...base.policy, endpoint: 'http://dify.example' } })).toThrow()
+    expect(() => validateStagedTransition({ ...base, policy: { ...base.policy, source: 'web' } })).toThrow()
+    expect(() => validateStagedTransition({ ...base, watchModels: ['a', 'a'] })).toThrow()
+    for (const endpoint of ['https:dify.example/v1', 'https:/dify.example', 'https:///dify.example', 'ftp://dify.example']) {
+      expect(() => validateStagedTransition({ ...base, policy: { ...base.policy, endpoint } })).toThrow()
+      expect(() => validateStagedTransition({ ...base, endpoint })).toThrow()
+    }
+    expect(() =>
+      validateStagedTransition({ ...base, prefilter: { ...base.prefilter, target: base.autoRoute.model } })
+    ).toThrow()
+  })
 })

apps/desktop/electron/staged-transition.ts

@@ -3,16 +3,78 @@ import path from 'node:path'
 
 import defaults from '../assets/codex-bridge/jev-settings-defaults.json'
 
-import type { StagedTransitionPatch, StagedTransitionSettings, StagedTransitionState } from './staged-transition-types'
+import type {
+  StagedTransitionPatch,
+  StagedTransitionPolicyStatus,
+  StagedTransitionSettings,
+  StagedTransitionState
+} from './staged-transition-types'
 
 export const stagedTransitionDefaults = defaults as StagedTransitionSettings
 
-export function validateStagedTransition(value: unknown): StagedTransitionSettings {
-  if (!value || typeof value !== 'object') {
+// Sections added in schema 2 (14 Oct 2026). Mirrors codex-bridge/jev_settings.py: a missing section or
+// field comes from the defaults, so a schema 1 file stays valid and every new stage starts disabled.
+const SECTIONS = ['watchModels', 'prefilter', 'autoRoute', 'finishCheck', 'verifierCheck', 'policy'] as const
+const POLICY_FILE = 'jev-policy.json'
+
+type Plain = Record<string, unknown>
+
+const isPlain = (value: unknown): value is Plain => Boolean(value) && typeof value === 'object' && !Array.isArray(value)
+
+function fill(value: unknown, fallback: unknown): unknown {
+  if (!isPlain(fallback) || !isPlain(value)) {
+    return value
+  }
+  const out: Plain = { ...value }
+
+  for (const [key, def] of Object.entries(fallback)) {
+    out[key] = key in value ? fill(value[key], def) : structuredClone(def)
+  }
+
+  return out
+}
+
+export function withSchemaDefaults(value: unknown): unknown {
+  if (!isPlain(value)) {
+    return value
+  }
+  const out: Plain = { ...value }
+  const defs = stagedTransitionDefaults as unknown as Plain
+
+  for (const section of SECTIONS) {
+    out[section] = section in value ? fill(value[section], defs[section]) : structuredClone(defs[section])
+  }
+
+  return out
+}
+
+const text = (s: unknown, max = 10000): s is string => typeof s === 'string' && s.trim().length > 0 && s.length <= max
+const probability = (n: unknown): n is number => typeof n === 'number' && Number.isFinite(n) && n >= 0 && n <= 1
+const integer = (n: unknown, min: number, max: number): n is number =>
+  typeof n === 'number' && Number.isInteger(n) && n >= min && n <= max
+
+// Same acceptance as the bridge (urllib.parse.urlsplit): the literal https:// prefix and a host. WHATWG URL alone
+// also accepts "https:host" and "https:/host", which the bridge rejects.
+function https(value: unknown): value is string {
+  if (!text(value, 2048) || !/^https:\/\/[^/?#\s]/i.test(value.trim())) {
+    return false
+  }
+  let url: URL
+
+  try {
+    url = new URL(value.trim())
+  } catch {
+    return false
+  }
+
+  return url.protocol === 'https:' && Boolean(url.hostname) && !url.username && !url.password && !url.hash
+}
+
+export function validateStagedTransition(input: unknown): StagedTransitionSettings {
+  if (!input || typeof input !== 'object') {
     throw new Error('Invalid settings')
   }
-  const v = value as StagedTransitionSettings
-  const text = (s: unknown, max = 10000): s is string => typeof s === 'string' && s.trim().length > 0 && s.length <= max
+  const v = withSchemaDefaults(input) as StagedTransitionSettings
 
   const list = (s: unknown, allowEmpty: boolean) =>
     Array.isArray(s) &&
@@ -21,15 +83,13 @@ export function validateStagedTransition(value: unknown): StagedTransitionSettin
     s.every(x => text(x, 256)) &&
     new Set(s.map(x => x.trim())).size === s.length
 
-  const seconds = (n: unknown) => typeof n === 'number' && Number.isInteger(n) && n >= 1 && n <= 3600
+  const seconds = (n: unknown) => integer(n, 1, 3600)
 
   if (typeof v.enabled !== 'boolean' || !text(v.endpoint, 2048) || !text(v.model, 256)) {
     throw new Error('Invalid connection settings')
   }
 
-  const url = new URL(v.endpoint)
-
-  if (url.protocol !== 'https:' || url.username || url.password || url.hash) {
+  if (!https(v.endpoint)) {
     throw new Error('HTTPS endpoint required')
   }
 
@@ -60,13 +120,7 @@ export function validateStagedTransition(value: unknown): StagedTransitionSettin
   }
 
   for (const id of ['ret', 'sart'] as const) {
-    if (
-      !text(v.questions?.[id]) ||
-      typeof v.thresholds?.[id] !== 'number' ||
-      !Number.isFinite(v.thresholds[id]) ||
-      v.thresholds[id] < 0 ||
-      v.thresholds[id] > 1
-    ) {
+    if (!text(v.questions?.[id]) || !probability(v.thresholds?.[id])) {
       throw new Error('Invalid evaluation rule')
     }
 
@@ -80,28 +134,117 @@ export function validateStagedTransition(value: unknown): StagedTransitionSettin
   if (
     !seconds(v.timeoutSeconds) ||
     !seconds(v.queueWaitSeconds) ||
-    !Number.isInteger(v.maxConcurrent) ||
-    v.maxConcurrent < 0 ||
-    v.maxConcurrent > 512 ||
+    !integer(v.maxConcurrent, 0, 512) ||
     !['pass', 'next'].includes(v.failureAction)
   ) {
     throw new Error('Invalid request limits')
   }
 
+  if (!list(v.watchModels, true)) {
+    throw new Error('Invalid watch models')
+  }
+
+  const p = v.prefilter
+
+  if (
+    typeof p?.enabled !== 'boolean' ||
+    !text(p.question) ||
+    !probability(p.threshold) ||
+    !text(p.target, 256) ||
+    !integer(p.timeoutSeconds, 1, 60)
+  ) {
+    throw new Error('Invalid prefilter')
+  }
+
+  const a = v.autoRoute
+
+  if (
+    typeof a?.enabled !== 'boolean' ||
+    !text(a.model, 256) ||
+    !integer(a.timeoutSeconds, 1, 60) ||
+    (['zor', 'arastirma'] as const).some(k => !text(a.questions?.[k]) || !probability(a.thresholds?.[k])) ||
+    (['basit', 'zor', 'arastirma'] as const).some(k => !text(a.targets?.[k], 256))
+  ) {
+    throw new Error('Invalid automatic routing')
+  }
+
+  if (Object.values(a.targets).some(t => t.trim() === a.model.trim()) || p.target.trim() === a.model.trim()) {
+    throw new Error('Automatic routing cannot target itself')
+  }
+
+  const f = v.finishCheck
+
+  if (
+    typeof f?.enabled !== 'boolean' ||
+    !text(f.question) ||
+    !probability(f.threshold) ||
+    !text(f.note, 4000)
+  ) {
+    throw new Error('Invalid finish check')
+  }
+
+  const c = v.verifierCheck
+
+  if (typeof c?.enabled !== 'boolean' || !text(c.question) || !probability(c.threshold)) {
+    throw new Error('Invalid verifier check')
+  }
+
+  const pol = v.policy
+
+  if (!['local', 'dify'].includes(pol?.source) || !https(pol.endpoint) || !integer(pol.refreshMinutes, 1, 1440)) {
+    throw new Error('Invalid policy source')
+  }
+
+  const trimmed = (s: string) => s.trim()
+
   return {
     enabled: v.enabled,
     endpoint: v.endpoint.trim(),
     model: v.model.trim(),
     fallbackModel: v.fallbackModel.trim(),
     rejectionRules: v.rejectionRules.map(r => ({ from: r.from.trim(), to: r.to.trim() })),
-    exemptModels: v.exemptModels.map(x => x.trim()),
+    exemptModels: v.exemptModels.map(trimmed),
     questions: { ...v.questions },
     thresholds: { ...v.thresholds },
     criteria: structuredClone(v.criteria),
     timeoutSeconds: v.timeoutSeconds,
     maxConcurrent: v.maxConcurrent,
     queueWaitSeconds: v.queueWaitSeconds,
-    failureAction: v.failureAction
+    failureAction: v.failureAction,
+    watchModels: v.watchModels.map(trimmed),
+    prefilter: { ...p, target: p.target.trim() },
+    autoRoute: {
+      enabled: a.enabled,
+      model: a.model.trim(),
+      timeoutSeconds: a.timeoutSeconds,
+      questions: { zor: a.questions.zor, arastirma: a.questions.arastirma },
+      thresholds: { zor: a.thresholds.zor, arastirma: a.thresholds.arastirma },
+      targets: { basit: a.targets.basit.trim(), zor: a.targets.zor.trim(), arastirma: a.targets.arastirma.trim() }
+    },
+    finishCheck: { enabled: f.enabled, question: f.question, threshold: f.threshold, note: f.note },
+    verifierCheck: { enabled: c.enabled, question: c.question, threshold: c.threshold },
+    policy: { source: pol.source, endpoint: pol.endpoint.trim(), refreshMinutes: pol.refreshMinutes }
+  }
+}
+
+// The bridge writes jev-policy.json after each Dify fetch; only a summary reaches the renderer.
+export function readPolicyStatus(directory: string): StagedTransitionPolicyStatus | null {
+  try {
+    const data = JSON.parse(fs.readFileSync(path.join(directory, POLICY_FILE), 'utf8'))
+
+    if (!isPlain(data)) {
+      return null
+    }
+
+    return {
+      fetchedAt: typeof data.fetchedAt === 'string' ? data.fetchedAt : undefined,
+      lastGoodAt: typeof data.lastGoodAt === 'string' ? data.lastGoodAt : undefined,
+      ok: data.ok === true,
+      error: typeof data.error === 'string' && data.error ? data.error.slice(0, 500) : undefined,
+      sections: isPlain(data.overrides) ? Object.keys(data.overrides) : []
+    }
+  } catch {
+    return null
   }
 }
 
@@ -112,13 +255,17 @@ export function createStagedTransitionStore(
 ) {
   const file = path.join(directory, 'jev-settings.json')
 
-  const read = (): { settings: StagedTransitionSettings; protectedKey?: string } => {
+  const read = (): { settings: StagedTransitionSettings; protectedKey?: string; protectedPolicyKey?: string } => {
     if (!fs.existsSync(file)) {
       return { settings: structuredClone(stagedTransitionDefaults) }
     }
     const data = JSON.parse(fs.readFileSync(file, 'utf8'))
 
-    return { settings: validateStagedTransition(data.settings), protectedKey: data.protectedKey }
+    return {
+      settings: validateStagedTransition(data.settings),
+      protectedKey: data.protectedKey,
+      protectedPolicyKey: data.protectedPolicyKey
+    }
   }
 
   const state = (): StagedTransitionState => {
@@ -135,32 +282,40 @@ export function createStagedTransitionStore(
       )
     }
 
-    return { settings: current.settings, keyConfigured: Boolean(current.protectedKey) || legacy }
+    return {
+      settings: current.settings,
+      keyConfigured: Boolean(current.protectedKey) || legacy,
+      policyKeyConfigured: Boolean(current.protectedPolicyKey),
+      policyStatus: readPolicyStatus(directory)
+    }
+  }
+
+  const secret = (value: unknown, name: string) => {
+    if (value !== undefined && (typeof value !== 'string' || value.length > 8192)) {
+      throw new Error(`Invalid ${name}`)
+    }
   }
 
   return {
     get: state,
     save(patch: StagedTransitionPatch): StagedTransitionState {
       const settings = validateStagedTransition(patch?.settings)
-
-      if (patch.apiKey !== undefined && (typeof patch.apiKey !== 'string' || patch.apiKey.length > 8192)) {
-        throw new Error('Invalid API key')
-      }
+      secret(patch.apiKey, 'API key')
+      secret(patch.policyApiKey, 'policy key')
 
       const current = read()
 
-      const protectedKey =
-        patch.apiKey === undefined
-          ? current.protectedKey
-          : patch.apiKey.trim()
-            ? protect(patch.apiKey.trim())
-            : undefined
+      const update = (value: string | undefined, previous: string | undefined) =>
+        value === undefined ? previous : value.trim() ? protect(value.trim()) : undefined
+
+      const protectedKey = update(patch.apiKey, current.protectedKey)
+      const protectedPolicyKey = update(patch.policyApiKey, current.protectedPolicyKey)
 
       fs.mkdirSync(directory, { recursive: true })
       const tmp = `${file}.${process.pid}.tmp`
 
       try {
-        fs.writeFileSync(tmp, JSON.stringify({ settings, protectedKey }, null, 2), { mode: 0o600 })
+        fs.writeFileSync(tmp, JSON.stringify({ settings, protectedKey, protectedPolicyKey }, null, 2), { mode: 0o600 })
         fs.renameSync(tmp, file)
       } finally {
         if (fs.existsSync(tmp)) {

apps/desktop/package.json

@@ -2,7 +2,7 @@
   "name": "aiturk-ide",
   "productName": "AITURK IDE",
   "private": true,
-  "version": "1.0.0-beta.33",
+  "version": "1.0.0-beta.39",
   "description": "TurkServis resmi yapay zekâ geliştirme ortamı. Hermes Agent tabanlıdır.",
   "author": "AITURK / TurkServis",
   "repository": {

apps/desktop/src/app/settings/codex-link-settings.test.tsx

@@ -12,6 +12,7 @@ vi.mock('@/store/notifications', () => ({ notifyError }))
 
 const RUNNING: CodexLinkStatus = {
   enabled: true,
+  mod: 'aiturk',
   codexFound: true,
   venvReady: true,
   foreign: false,
@@ -198,3 +199,18 @@ describe('Codex Link settings', () => {
     expect(get).not.toHaveBeenCalled()
   })
 })
+
+
+describe('connection mode controls', () => {
+  it('sends the mode and renders the saved direct preference', async () => {
+    get.mockResolvedValue({ ...RUNNING, mod: 'dogrudan' })
+    set.mockResolvedValue({ ...RUNNING, mod: 'aiturk' })
+    renderPage()
+    const direct = await screen.findByRole('radio', { name: 'Doğrudan (önerilen): abonelik modelleri köprüden bağımsız' })
+    await waitFor(() => expect((direct as HTMLInputElement).checked).toBe(true))
+    fireEvent.click(screen.getByRole('radio', { name: 'AITURK: combolar Codex listesinde, tüm modeller köprüden' }))
+    await waitFor(() => expect(set).toHaveBeenCalledWith({ mod: 'aiturk' }))
+    await waitFor(() => expect((direct as HTMLInputElement).checked).toBe(false))
+    expect(screen.getByText("Codex'i yeniden başlatın")).toBeTruthy()
+  })
+})

apps/desktop/src/app/settings/codex-link-settings.tsx

@@ -57,7 +57,7 @@ export function codexLinkStatusLines(status: CodexLinkStatus, copy: CodexLinkCop
 
   if (status.ideDurum === 'anahtar-yok') {
     lines.push({ id: 'ide', text: copy.signIn, tone: 'warn' })
-  } else if (status.ideDurum === 'tamam' && status.ideModel !== null) {
+  } else if (status.mod === 'aiturk' && status.ideDurum === 'tamam' && status.ideModel !== null) {
     lines.push({ id: 'ide', text: copy.models(status.ideModel), tone: 'ok' })
   }
 
@@ -170,6 +170,27 @@ export function CodexLinkSettings() {
           title={copy.title}
         />
 
+        <ListRow
+          title={copy.modeTitle}
+          below={
+            <fieldset disabled={!status || busy !== null} className="grid gap-2 py-2">
+              {(['dogrudan', 'aiturk'] as const).map(mod => (
+                <label key={mod} className="flex min-h-11 cursor-pointer items-center gap-2">
+                  <input
+                    type="radio"
+                    name="codex-link-mode"
+                    value={mod}
+                    checked={(status?.mod ?? 'dogrudan') === mod}
+                    onChange={() => void change({ mod }, 'toggle')}
+                  />
+                  <span>{mod === 'dogrudan' ? copy.directMode : copy.aiturkMode}</span>
+                </label>
+              ))}
+              <p className="text-(--ui-text-tertiary)">{copy.modeRestartNote}</p>
+            </fieldset>
+          }
+        />
+
         {!status && !loadFailed && <ListRowSkeleton wide />}
 
         {loadFailed && !status && (

apps/desktop/src/app/settings/staged-transition-settings.test.tsx

@@ -44,13 +44,13 @@ describe('staged transition settings UI', () => {
     show()
     await screen.findByText('Kademeli Geçiş')
     fireEvent.click(screen.getByText('+ Geçiş kuralı ekle'))
-    expect(screen.getByLabelText('İtiraz edilen model 4')).toBeTruthy()
-    expect(screen.getByLabelText('Kullanılacak model 4')).toBeTruthy()
-    fireEvent.click(screen.getByLabelText('Geçiş kuralı 4 sil'))
-    expect(screen.queryByLabelText('İtiraz edilen model 4')).toBeNull()
+    expect(screen.getByLabelText('İtiraz edilen model 3')).toBeTruthy()
+    expect(screen.getByLabelText('Kullanılacak model 3')).toBeTruthy()
+    fireEvent.click(screen.getByLabelText('Geçiş kuralı 3 sil'))
+    expect(screen.queryByLabelText('İtiraz edilen model 3')).toBeNull()
     fireEvent.click(screen.getByText('+ Her zaman geç kuralı ekle'))
-    expect(screen.getByLabelText('Her zaman geçen model 3')).toBeTruthy()
-    fireEvent.click(screen.getByLabelText('Her zaman geç kuralı 3 sil'))
+    expect(screen.getByLabelText('Her zaman geçen model 4')).toBeTruthy()
+    fireEvent.click(screen.getByLabelText('Her zaman geç kuralı 4 sil'))
     fireEvent.change(screen.getByLabelText('İsteği yerine getirmeme denetim metni'), {
       target: { value: 'custom prompt' }
     })
@@ -58,6 +58,37 @@ describe('staged transition settings UI', () => {
     await screen.findByText('Kaydedildi. Yeni değerlendirmelerde uygulanır.')
     expect(set.mock.calls[0][0].settings.questions.ret).toBe('custom prompt')
     expect(set.mock.calls[0][0]).not.toHaveProperty('apiKey')
+    expect(set.mock.calls[0][0]).not.toHaveProperty('policyApiKey')
+  })
+  it('edits the decision stages, the correction channel and the Dify rules source', async () => {
+    get.mockResolvedValue({
+      ...state(),
+      policyKeyConfigured: false,
+      policyStatus: { ok: true, fetchedAt: 'dün', sections: ['autoRoute'], error: 'Dify kapalı' }
+    })
+    show()
+    await screen.findByText('Karar aşamaları')
+    fireEvent.click(screen.getByLabelText('Ret ön kontrolü'))
+    fireEvent.change(screen.getByLabelText('Ret ön kontrolü eşiği'), { target: { value: '0.75' } })
+    fireEvent.click(screen.getByLabelText('Otomatik model'))
+    fireEvent.change(screen.getByLabelText('Zor iş sorusu'), { target: { value: 'zor mu?' } })
+    fireEvent.click(screen.getByLabelText('Erken bitiş denetimi'))
+    fireEvent.change(screen.getByLabelText('Modele verilecek not'), { target: { value: 'işi bitir' } })
+    fireEvent.click(screen.getByLabelText('Workflow doğrulayıcı elemesi'))
+    fireEvent.click(screen.getByText('+ Düzeltme kanalı modeli ekle'))
+    expect(screen.getByLabelText('Düzeltme kanalı modeli 4')).toBeTruthy()
+    fireEvent.click(screen.getByLabelText('Düzeltme kanalı modeli 4 sil'))
+    fireEvent.change(screen.getByLabelText('Dify uygulama anahtarı'), { target: { value: 'app-key' } })
+    fireEvent.click(screen.getByText('Kaydet'))
+    await screen.findByText('Kaydedildi. Yeni değerlendirmelerde uygulanır.')
+    const saved = set.mock.calls[0][0]
+    expect(saved.settings.prefilter).toMatchObject({ enabled: true, threshold: 0.75 })
+    expect(saved.settings.autoRoute).toMatchObject({ enabled: true, questions: { zor: 'zor mu?' } })
+    expect(saved.settings.finishCheck).toMatchObject({ enabled: true, note: 'işi bitir' })
+    expect(saved.settings.verifierCheck.enabled).toBe(true)
+    expect(saved.settings.watchModels).toEqual(defaults.watchModels)
+    expect(saved.policyApiKey).toBe('app-key')
+    expect((screen.getByLabelText('Dify uygulama anahtarı') as HTMLInputElement).value).toBe('')
   })
   it('retains user edits if persistence fails', async () => {
     set.mockRejectedValue(new Error('disk error'))

apps/desktop/src/app/settings/staged-transition-settings.tsx

@@ -21,6 +21,7 @@ export function StagedTransitionSettingsView() {
   const [state, setState] = useState<StagedTransitionState | null>(null)
   const [draft, setDraft] = useState<StagedTransitionSettings | null>(null)
   const [key, setKey] = useState('')
+  const [policyKey, setPolicyKey] = useState('')
   const [busy, setBusy] = useState(false)
   const [message, setMessage] = useState('')
   const [error, setError] = useState(false)
@@ -80,7 +81,10 @@ export function StagedTransitionSettingsView() {
   const storedModels = [
     draft.fallbackModel,
     ...draft.exemptModels,
-    ...draft.rejectionRules.flatMap(rule => [rule.from, rule.to])
+    ...draft.rejectionRules.flatMap(rule => [rule.from, rule.to]),
+    ...draft.watchModels,
+    draft.prefilter.target,
+    ...Object.values(draft.autoRoute.targets)
   ]
 
   for (const id of storedModels) {
@@ -127,14 +131,62 @@ export function StagedTransitionSettingsView() {
     />
   )
 
+  // Decision stages (14 Oct 2026). Each stage has its own switch; all start disabled.
+  type StageName = 'prefilter' | 'autoRoute' | 'finishCheck' | 'verifierCheck'
+
+  const stage = <K extends StageName>(name: K, value: Partial<StagedTransitionSettings[K]>) =>
+    change(name, { ...draft[name], ...value } as StagedTransitionSettings[K])
+
+  const probabilityInput = (label: string, value: number, onChange: (value: number) => void) => (
+    <Input
+      aria-label={label}
+      max={1}
+      min={0}
+      onChange={e => onChange(Number(e.target.value))}
+      step={0.01}
+      type="number"
+      value={value}
+    />
+  )
+
+  const secondsInput = (label: string, value: number, max: number, onChange: (value: number) => void) => (
+    <Input aria-label={label} max={max} min={1} onChange={e => onChange(Number(e.target.value))} type="number" value={value} />
+  )
+
+  const question = (label: string, value: string, onChange: (value: string) => void, rows = 3) => (
+    <label className="block py-2">
+      <span>{label}</span>
+      <Textarea aria-label={label} onChange={e => onChange(e.target.value)} rows={rows} value={value} />
+    </label>
+  )
+
+  const stageSwitch = (name: StageName, label: string, description: string) => (
+    <ListRow
+      action={
+        <Switch aria-label={label} checked={draft[name].enabled} onCheckedChange={value => stage(name, { enabled: value })} />
+      }
+      description={description}
+      title={label}
+    />
+  )
+
+  const policy = state?.policyStatus
+
   const save = async () => {
     setBusy(true)
     setMessage('')
     setError(false)
 
     try {
-      adopt(await api.setStagedTransition({ settings: draft, ...(key.trim() ? { apiKey: key.trim() } : {}) }))
+      adopt(
+        await api.setStagedTransition({
+          settings: draft,
+          ...(key.trim() ? { apiKey: key.trim() } : {}),
+          ...(policyKey.trim() ? { policyApiKey: policyKey.trim() } : {})
+        })
+      )
       setKey('')
+      setPolicyKey('')
       setMessage(text('Kaydedildi. Yeni değerlendirmelerde uygulanır.', 'Saved. Applies to new evaluations.'))
     } catch (failure) {
       setError(true)
@@ -404,6 +456,248 @@ export function StagedTransitionSettingsView() {
             {text('+ Her zaman geç kuralı ekle', '+ Add always-pass rule')}
           </Button>
         </SettingsSection>
+        <SettingsSection icon={Link} title={text('Karar aşamaları', 'Decision stages')}>
+          <p>
+            {text(
+              'Karar modeli metin yazmaz; her aşamada evet/hayır olasılığı verir. Aşamalar yukarıdaki ana anahtar açıkken çalışır. Karar alınamazsa bugünkü yol izlenir.',
+              'The decision model writes no text; each stage gets a yes/no probability. Stages run while the main switch above is on. Without a decision the current path is kept.'
+            )}
+          </p>
+          {stageSwitch(
+            'prefilter',
+            text('Ret ön kontrolü', 'Refusal pre-check'),
+            text(
+              'Tur başında sorulur: normal bir model bu isteği reddeder ya da yumuşatır mı? Evetse adım beklemeden seçilen katmandan başlar.',
+              'Asked at the start of a turn: would a mainstream model refuse or water down this request? If so the step starts at the chosen layer.'
+            )
+          )}
+          <ListRow
+            action={modelSelect(text('Ret ön kontrolü hedefi', 'Refusal pre-check target'), draft.prefilter.target, value =>
+              stage('prefilter', { target: value })
+            )}
+            title={text('Reddedilecekse başlanacak model', 'Model to start with when a refusal is expected')}
+          />
+          <ListRow
+            action={probabilityInput(text('Ret ön kontrolü eşiği', 'Refusal pre-check threshold'), draft.prefilter.threshold, value =>
+              stage('prefilter', { threshold: value })
+            )}
+            title={text('Eşik (0–1)', 'Threshold (0–1)')}
+          />
+          {question(text('Ret ön kontrolü sorusu', 'Refusal pre-check question'), draft.prefilter.question, value =>
+            stage('prefilter', { question: value })
+          )}
+          {stageSwitch(
+            'autoRoute',
+            text('Otomatik model', 'Automatic model'),
+            text(
+              'Codex listesinde bir model olarak görünür. Seçildiğinde her yeni istekte karar modeli işin türüne göre combo seçer; aynı turun araç adımları aynı combo ile sürer. Açınca listede birkaç dakika içinde görünür.',
+              'Appears as a model in the Codex list. When selected, the decision model picks a combo for each new request; tool steps of the same turn keep it. It appears in the list within a few minutes after enabling.'
+            )
+          )}
+          <ListRow
+            action={
+              <Input
+                aria-label={text('Otomatik modelin adı', 'Automatic model name')}
+                onChange={e => stage('autoRoute', { model: e.target.value })}
+                value={draft.autoRoute.model}
+              />
+            }
+            title={text('Listede görünecek ad', 'Name in the model list')}
+          />
+          {(['basit', 'zor', 'arastirma'] as const).map(kind => {
+            const label =
+              kind === 'basit'
+                ? text('Basit iş combo', 'Simple request combo')
+                : kind === 'zor'
+                  ? text('Zor iş combo', 'Hard request combo')
+                  : text('Araştırma combo', 'Research combo')
+
+            return (
+              <ListRow
+                action={modelSelect(label, draft.autoRoute.targets[kind], value =>
+                  stage('autoRoute', { targets: { ...draft.autoRoute.targets, [kind]: value } })
+                )}
+                key={kind}
+                title={label}
+              />
+            )
+          })}
+          {(['zor', 'arastirma'] as const).map(kind => {
+            const label = kind === 'zor' ? text('Zor iş sorusu', 'Hard request question') : text('Araştırma sorusu', 'Research question')
+
+            return (
+              <div key={kind}>
+                <ListRow
+                  action={probabilityInput(`${label} ${text('eşiği', 'threshold')}`, draft.autoRoute.thresholds[kind], value =>
+                    stage('autoRoute', { thresholds: { ...draft.autoRoute.thresholds, [kind]: value } })
+                  )}
+                  title={`${label} ${text('eşiği', 'threshold')}`}
+                />
+                {question(label, draft.autoRoute.questions[kind], value =>
+                  stage('autoRoute', { questions: { ...draft.autoRoute.questions, [kind]: value } })
+                )}
+              </div>
+            )
+          })}
+          {stageSwitch(
+            'finishCheck',
+            text('Erken bitiş denetimi', 'Early finish check'),
+            text(
+              'Son cevapta sorulur: iş bitmeden “bitti” dendi mi ya da kanıt gösterilmedi mi? Evetse cevap aşağıdaki notla aynı modele bir kez geri verilir.',
+              'Asked on the final answer: did it say done before finishing or claim success without evidence? If so it goes back to the same model once with the note below.'
+            )
+          )}
+          <ListRow
+            action={probabilityInput(text('Erken bitiş eşiği', 'Early finish threshold'), draft.finishCheck.threshold, value =>
+              stage('finishCheck', { threshold: value })
+            )}
+            title={text('Eşik (0–1)', 'Threshold (0–1)')}
+          />
+          {question(text('Erken bitiş sorusu', 'Early finish question'), draft.finishCheck.question, value =>
+            stage('finishCheck', { question: value })
+          )}
+          {question(
+            text('Modele verilecek not', 'Note given to the model'),
+            draft.finishCheck.note,
+            value => stage('finishCheck', { note: value }),
+            2
+          )}
+          {stageSwitch(
+            'verifierCheck',
+            text('Workflow doğrulayıcı elemesi', 'Workflow reviewer check'),
+            text(
+              'Dinamik workflow kabulünde sorulur: doğrulayıcı somut kanıt göstermeden mi onayladı? Evetse kabul engellenir, doğrulama yeniden yapılır.',
+              'Asked when a dynamic workflow is accepted: did the reviewer approve without concrete evidence? If so acceptance is blocked and verification is redone.'
+            )
+          )}
+          <ListRow
+            action={probabilityInput(text('Doğrulayıcı elemesi eşiği', 'Reviewer check threshold'), draft.verifierCheck.threshold, value =>
+              stage('verifierCheck', { threshold: value })
+            )}
+            title={text('Eşik (0–1)', 'Threshold (0–1)')}
+          />
+          {question(text('Doğrulayıcı elemesi sorusu', 'Reviewer check question'), draft.verifierCheck.question, value =>
+            stage('verifierCheck', { question: value })
+          )}
+          <ListRow
+            action={secondsInput(text('Tur başı karar bekleme (saniye)', 'Turn-start decision wait (seconds)'), draft.prefilter.timeoutSeconds, 60, value => {
+              setDraft({
+                ...draft,
+                prefilter: { ...draft.prefilter, timeoutSeconds: value },
+                autoRoute: { ...draft.autoRoute, timeoutSeconds: value }
+              })
+            })}
+            description={text(
+              'Bu sürede karar gelmezse istek bugünkü yoldan devam eder.',
+              'Without a decision within this time the request continues on the current path.'
+            )}
+            title={text('Tur başı karar bekleme (saniye)', 'Turn-start decision wait (seconds)')}
+          />
+        </SettingsSection>
+        <SettingsSection icon={Link} title={text('Cevaptan sonra düzeltme kanalı', 'Correction channel after answers')}>
+          <p>
+            {text(
+              'Bekçi bu modellerin cevabından sonra düzeltme ya da ek bilgi gönderebilir. Ad tam eşleşmelidir.',
+              'Bekçi may send corrections or extra information after these models answer. Names must match exactly.'
+            )}
+          </p>
+          {draft.watchModels.map((model, index) => (
+            <div className="flex flex-wrap items-center gap-2 py-2" key={index}>
+              {modelSelect(text(`Düzeltme kanalı modeli ${index + 1}`, `Correction channel model ${index + 1}`), model, value =>
+                change(
+                  'watchModels',
+                  draft.watchModels.map((m, i) => (i === index ? value : m))
+                )
+              )}
+              <Button
+                aria-label={text(`Düzeltme kanalı modeli ${index + 1} sil`, `Remove correction channel model ${index + 1}`)}
+                onClick={() =>
+                  change(
+                    'watchModels',
+                    draft.watchModels.filter((_, i) => i !== index)
+                  )
+                }
+                variant="ghost"
+              >
+                {text('Sil', 'Remove')}
+              </Button>
+            </div>
+          ))}
+          <Button onClick={() => change('watchModels', [...draft.watchModels, ''])} variant="outline">
+            {text('+ Düzeltme kanalı modeli ekle', '+ Add correction channel model')}
+          </Button>
+        </SettingsSection>
+        <SettingsSection icon={Link} title={text('Kural kaynağı', 'Rules source')}>
+          <p>
+            {text(
+              'Dify seçilirse karar aşamalarının soruları, eşikleri ve combo seçimleri Dify’daki iş akışından birkaç dakikada bir alınır. Codex’in konuştuğu model yine OmniRoute combo’sudur. Dify’a ulaşılamazsa son geçerli kurallar, o da yoksa bu sayfadaki ayarlar kullanılır.',
+              'With Dify, the stage questions, thresholds and combo choices are fetched from the Dify workflow every few minutes. Codex still talks to OmniRoute combos. If Dify is unreachable the last good rules, otherwise the settings on this page, are used.'
+            )}
+          </p>
+          <ListRow
+            action={
+              <Select
+                onValueChange={value => change('policy', { ...draft.policy, source: value as 'local' | 'dify' })}
+                value={draft.policy.source}
+              >
+                <SelectTrigger aria-label={text('Kural kaynağı', 'Rules source')}>
+                  <SelectValue />
+                </SelectTrigger>
+                <SelectContent>
+                  <SelectItem value="local">{text('Bu sayfa', 'This page')}</SelectItem>
+                  <SelectItem value="dify">Dify</SelectItem>
+                </SelectContent>
+              </Select>
+            }
+            title={text('Kural kaynağı', 'Rules source')}
+          />
+          <ListRow
+            action={
+              <Input
+                aria-label={text('Dify API adresi', 'Dify API endpoint')}
+                onChange={e => change('policy', { ...draft.policy, endpoint: e.target.value })}
+                type="url"
+                value={draft.policy.endpoint}
+              />
+            }
+            title={text('Dify API adresi', 'Dify API endpoint')}
+          />
+          <ListRow
+            action={
+              <Input
+                aria-label={text('Dify uygulama anahtarı', 'Dify app key')}
+                autoComplete="new-password"
+                onChange={e => setPolicyKey(e.target.value)}
+                type="password"
+                value={policyKey}
+              />
+            }
+            description={
+              state?.policyKeyConfigured
+                ? text('Anahtar tanımlı. Değiştirmek için yeni anahtarı girin.', 'Key configured. Enter a new key to replace it.')
+                : text('Henüz anahtar tanımlı değil.', 'No key configured.')
+            }
+            title={text('Dify uygulama anahtarı', 'Dify app key')}
+          />
+          <ListRow
+            action={secondsInput(text('Yenileme aralığı (dakika)', 'Refresh interval (minutes)'), draft.policy.refreshMinutes, 1440, value =>
+              change('policy', { ...draft.policy, refreshMinutes: value })
+            )}
+            title={text('Yenileme aralığı (dakika)', 'Refresh interval (minutes)')}
+          />
+          {draft.policy.source === 'dify' && (
+            <p role="status">
+              {!policy
+                ? text('Dify kuralları henüz alınmadı.', 'Dify rules not fetched yet.')
+                : policy.ok
+                  ? text(
+                      `Son geçerli kurallar: ${policy.lastGoodAt ?? policy.fetchedAt ?? '-'} (${policy.sections.join(', ') || 'boş'})${policy.error ? ` · son deneme hatası: ${policy.error}` : ''}`,
+                      `Last good rules: ${policy.lastGoodAt ?? policy.fetchedAt ?? '-'} (${policy.sections.join(', ') || 'empty'})${policy.error ? ` · last attempt failed: ${policy.error}` : ''}`
+                    )
+                  : text(`Kurallar alınamadı: ${policy.error ?? '-'}`, `Rules could not be fetched: ${policy.error ?? '-'}`)}
+            </p>
+          )}
+        </SettingsSection>
         <SettingsSection icon={Link} title={text('Paralellik ve bekleme', 'Concurrency and waiting')}>
           {number(
             'maxConcurrent',

apps/desktop/src/i18n/codex-link.ts

@@ -6,6 +6,10 @@ import { useI18n } from './context'
 // AITURK-distribution strings (see ./aiturk): Turkish for `tr`, English for
 // every other locale.
 const en = {
+  modeTitle: 'Connection mode',
+  directMode: 'Direct (recommended): subscription models independent of the bridge',
+  aiturkMode: 'AITURK: combos in the Codex list, all models through the bridge',
+  modeRestartNote: 'Restart Codex.',
   nav: 'Codex Link',
   title: 'Codex Link',
   description:
@@ -39,6 +43,10 @@ const en = {
 }
 
 const tr: typeof en = {
+  modeTitle: 'Bağlantı modu',
+  directMode: 'Doğrudan (önerilen): abonelik modelleri köprüden bağımsız',
+  aiturkMode: 'AITURK: combolar Codex listesinde, tüm modeller köprüden',
+  modeRestartNote: "Codex'i yeniden başlatın",
   nav: 'Codex Bağlama',
   title: 'Codex Bağlama',
   description:
@@ -71,10 +79,45 @@ const tr: typeof en = {
   restartNote: "Codex'te yeni modelleri görmek için Codex'i yeniden açın."
 }
 
+const modeTranslations = {
+  zh: {
+    modeTitle: '连接模式',
+    directMode: '直接（推荐）：订阅模型独立于桥接',
+    aiturkMode: 'AITURK：组合显示在 Codex 列表中，所有模型通过桥接',
+    modeRestartNote: '请重启 Codex。'
+  },
+  'zh-hant': {
+    modeTitle: '連線模式',
+    directMode: '直接（建議）：訂閱模型獨立於橋接',
+    aiturkMode: 'AITURK：組合顯示在 Codex 清單中，所有模型透過橋接',
+    modeRestartNote: '請重新啟動 Codex。'
+  },
+  ja: {
+    modeTitle: '接続モード',
+    directMode: '直接（推奨）：サブスクリプションモデルはブリッジから独立',
+    aiturkMode: 'AITURK：Codex の一覧にコンボを表示、すべてのモデルはブリッジ経由',
+    modeRestartNote: 'Codex を再起動してください。'
+  },
+  ar: {
+    modeTitle: 'وضع الاتصال',
+    directMode: 'مباشر (موصى به): نماذج الاشتراك مستقلة عن الجسر',
+    aiturkMode: 'AITURK: مجموعات النماذج في قائمة Codex، وجميع النماذج عبر الجسر',
+    modeRestartNote: 'أعد تشغيل Codex.'
+  },
+  ru: {
+    modeTitle: 'Режим подключения',
+    directMode: 'Напрямую (рекомендуется): модели подписки независимы от моста',
+    aiturkMode: 'AITURK: комбинации в списке Codex, все модели через мост',
+    modeRestartNote: 'Перезапустите Codex.'
+  }
+}
+
 export type CodexLinkCopy = typeof en
 
 export function useCodexLinkCopy(): CodexLinkCopy {
   const { locale } = useI18n()
 
-  return locale === 'tr' ? tr : en
+  if (locale === 'tr') return tr
+  if (locale === 'en') return en
+  return { ...en, ...modeTranslations[locale] }
 }

package-lock.json

@@ -65,7 +65,7 @@
     },
     "apps/desktop": {
       "name": "aiturk-ide",
-      "version": "1.0.0-beta.33",
+      "version": "1.0.0-beta.39",
       "license": "MIT",
       "dependencies": {
         "@assistant-ui/core": "0.2.23",

scripts/install.ps1

@@ -2550,6 +2550,39 @@ function Install-Repository {
     Write-Success "Repository ready"
 }
 
+function Test-ReusableManagedVenv {
+    param([string]$VenvPath, [string]$BasePython, [string]$Version)
+    $pythonExe = Join-Path $VenvPath "Scripts\python.exe"
+    if (-not (Test-Path -LiteralPath $pythonExe -PathType Leaf)) { return $false }
+    $process = New-Object System.Diagnostics.Process
+    try {
+        $info = New-Object System.Diagnostics.ProcessStartInfo
+        $info.FileName = $pythonExe
+        $info.Arguments = '-I -c "import json,sys,ssl,ctypes,venv,encodings; print(json.dumps(dict(version=str(sys.version_info.major)+''.''+str(sys.version_info.minor),prefix=sys.prefix,base=sys._base_executable)))"'
+        $info.UseShellExecute = $false
+        $info.CreateNoWindow = $true
+        $info.RedirectStandardOutput = $true
+        $info.RedirectStandardError = $true
+        $process.StartInfo = $info
+        if (-not $process.Start()) { return $false }
+        $stdout = $process.StandardOutput.ReadToEndAsync()
+        $stderr = $process.StandardError.ReadToEndAsync()
+        if (-not $process.WaitForExit(15000)) {
+            try { $process.Kill() } catch { }
+            return $false
+        }
+        if ($process.ExitCode -ne 0) { return $false }
+        $health = $stdout.Result | ConvertFrom-Json
+        return ($health.version -eq $Version -and
+            [string]::Equals([IO.Path]::GetFullPath($health.prefix), [IO.Path]::GetFullPath($VenvPath), [StringComparison]::OrdinalIgnoreCase) -and
+            [string]::Equals([IO.Path]::GetFullPath($health.base), [IO.Path]::GetFullPath($BasePython), [StringComparison]::OrdinalIgnoreCase))
+    } catch {
+        return $false
+    } finally {
+        $process.Dispose()
+    }
+}
+
 function Install-Venv {
     if ($NoVenv) {
         Write-Info "Skipping virtual environment (-NoVenv)"
@@ -2567,6 +2600,19 @@ function Install-Venv {
         throw "Hermes-managed Python is unavailable. Run install.ps1 -Stage python first."
     }
 
+    # Routine source updates do not require replacing a healthy interpreter.
+    # Recreating it kills detached Codex bridges sharing this venv and leaves
+    # every subscription model disconnected until bootstrap finishes. Verify
+    # version, provenance and stdlib first; the dependency stage still performs
+    # the locked sync and import checks. Broken/mismatched runtimes retain the
+    # transactional repair path below.
+    $existingVenvPath = Join-Path $InstallDir "venv"
+    if (Test-ReusableManagedVenv -VenvPath $existingVenvPath -BasePython $resolvedPython.Path -Version $resolvedPython.Version) {
+        $env:UV_PYTHON = Join-Path $existingVenvPath "Scripts\python.exe"
+        Write-Success "Reusing healthy managed virtual environment; running Codex bridges preserved"
+        return
+    }
+
     Write-Info "Creating virtual environment with Python $($resolvedPython.Version)..."
     
     Push-Location $InstallDir

tests/test_install_ps1_reuse_healthy_venv.py

@@ -0,0 +1,77 @@
+"""Run the actual installer functions against a real disposable Python venv."""
+import json
+import os
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+import pytest
+
+SOURCE = Path(__file__).resolve().parents[1] / 'scripts/install.ps1'
+PS = shutil.which('powershell') or shutil.which('pwsh')
+pytestmark = pytest.mark.skipif(os.name != 'nt' or not PS, reason='Windows installer runtime test')
+
+
+def function(source, name):
+    start = source.index('function ' + name + ' {')
+    opening = source.index('{', start)
+    depth = 0
+    for index in range(opening, len(source)):
+        if source[index] == '{': depth += 1
+        elif source[index] == '}': depth -= 1
+        if depth == 0: return source[start:index + 1]
+    raise AssertionError(name)
+
+
+@pytest.fixture(scope='module')
+def runtime(tmp_path_factory):
+    root = tmp_path_factory.mktemp('installer-reuse')
+    subprocess.run([sys.executable, '-m', 'venv', '--without-pip', str(root / 'venv')], check=True)
+    return root
+
+
+def run(runtime, body):
+    text = SOURCE.read_text(encoding='utf-8-sig')
+    script = runtime / 'probe.ps1'
+    prefix = "$ErrorActionPreference = 'Stop'\n"
+    prefix += function(text, 'Test-ReusableManagedVenv') + '\n'
+    prefix += function(text, 'Install-Venv') + '\n'
+    prefix += "$InstallDir = '" + str(runtime).replace("'", "''") + "'\n"
+    prefix += "$BasePython = '" + sys._base_executable.replace("'", "''") + "'\n"
+    prefix += "$Version = '" + str(sys.version_info.major) + '.' + str(sys.version_info.minor) + "'\n"
+    script.write_text(prefix + body, encoding='utf-8-sig')
+    result = subprocess.run([PS, '-NoProfile', '-File', str(script)], capture_output=True, text=True, timeout=40)
+    assert result.returncode == 0, result.stdout + result.stderr
+    return result.stdout
+
+
+def test_healthy_update_keeps_live_python_and_never_reaches_kill_sweep(runtime):
+    python = runtime / 'venv/Scripts/python.exe'
+    live = subprocess.Popen([str(python), '-c', 'import time;time.sleep(90)'])
+    try:
+        output = run(runtime, r'''
+function Resolve-AvailablePythonVersion { return @{Path=$BasePython;Version=$Version} }
+function Write-Success { param($Message); Write-Output $Message }
+function Write-Info { throw 'Unexpected venv recreation/kill path' }
+function taskkill { throw 'Live process must not be killed' }
+Install-Venv
+''')
+        assert 'Reusing healthy' in output
+        assert live.poll() is None
+        assert python.is_file()
+    finally:
+        live.terminate();live.wait(timeout=10)
+
+
+def test_wrong_version_or_foreign_interpreter_does_not_reuse(runtime):
+    output = run(runtime, r'''
+$venvPath = Join-Path $InstallDir 'venv'
+$results = @(
+  (Test-ReusableManagedVenv $venvPath $BasePython '0.0'),
+  (Test-ReusableManagedVenv $venvPath (Join-Path $InstallDir 'other-python.exe') $Version),
+  (Test-ReusableManagedVenv (Join-Path $InstallDir 'missing') $BasePython $Version)
+)
+ConvertTo-Json -Compress -InputObject $results
+''')
+    assert json.loads(output) == [False, False, False]

tests/tools/test_search_giant_line_containment.py

@@ -20,6 +20,7 @@ import subprocess
 import pytest
 
 from tools.file_operations import ShellFileOperations
+from tools.environments.local import LocalEnvironment
 
 # Big enough to prove containment, small enough to keep the test fast.
 GIANT = 5 * 1024 * 1024  # 5MB single line
@@ -27,22 +28,20 @@ GIANT = 5 * 1024 * 1024  # 5MB single line
 STDOUT_CEILING = 1 * 1024 * 1024
 
 
-class RecordingEnv:
+class RecordingEnv(LocalEnvironment):
     """Local bash executor that records the largest stdout it returned."""
 
     def __init__(self, cwd):
-        self.cwd = cwd
+        super().__init__(cwd=cwd)
         self.max_stdout = 0
 
     def execute(self, command, timeout=60, **kwargs):
-        proc = subprocess.run(
-            ["bash", "-c", command],
-            capture_output=True, text=True, errors="replace",
-            timeout=timeout + 30,
-        )
-        out = proc.stdout + (proc.stderr or "")
+        # Use the application's shell selection/path handling. On Windows a
+        # bare 'bash' may select WSL, whose filesystem is not the native one.
+        result = super().execute(command, timeout=timeout + 30, **kwargs)
+        out = result.get("output", "")
         self.max_stdout = max(self.max_stdout, len(out))
-        return {"output": out, "returncode": proc.returncode}
+        return result
 
 
 @pytest.fixture()
@@ -58,6 +57,8 @@ def _ops(giant_dir, engine):
     env = RecordingEnv(str(giant_dir))
     ops = ShellFileOperations(env)
     ops._has_command = lambda cmd: cmd == engine
+    resolve = ops._resolve_command
+    ops._resolve_command = lambda cmd: None if cmd == "rg" and engine != "rg" else resolve(cmd)
     return ops, env
 
 
@@ -96,5 +97,5 @@ def test_line_cap_skipped_for_path_and_count_modes(giant_dir, engine, output_mod
     if output_mode == "files_only":
         assert {os.path.basename(f) for f in result.files} == {"trace.json", "small.py"}
     else:
-        assert {os.path.basename(k) for k in result.counts} == {"trace.json", "small.py"}
+        assert {os.path.basename(k) for k, count in result.counts.items() if count} == {"trace.json", "small.py"}
     assert env.max_stdout < STDOUT_CEILING

tests/tools/test_search_project_scope.py

@@ -0,0 +1,112 @@
+"""Project scope and resource limits: real local paths, no broad subprocesses."""
+from unittest.mock import Mock
+
+from tools.file_operations import ShellFileOperations, SearchResult, ExecuteResult
+from tools.environments.local import LocalEnvironment
+
+
+def projects(tmp_path):
+    for name in ('one', 'two'):
+        project = tmp_path / name
+        project.mkdir()
+        (project / '.git').mkdir()
+        (project / 'source.py').write_text('needle\n')
+    return tmp_path / 'one'
+
+
+def test_ambiguous_scope_starts_no_process(tmp_path):
+    projects(tmp_path)
+    ops = ShellFileOperations(LocalEnvironment(str(tmp_path)))
+    ops._exec = Mock(side_effect=AssertionError('must not start process'))
+    result = ops.search('needle', str(tmp_path))
+    assert 'scope' in result.error.lower()
+    assert 'one' in result.error and 'two' in result.error
+    ops._exec.assert_not_called()
+
+
+def test_umbrella_uses_cwd_project_and_reports_it(tmp_path):
+    project = projects(tmp_path)
+    ops = ShellFileOperations(LocalEnvironment(str(project)))
+    ops._exec = Mock(return_value=ExecuteResult(stdout='exists', exit_code=0))
+    ops._search_content = Mock(return_value=SearchResult())
+    result = ops.search('needle', str(tmp_path))
+    assert ops._search_content.call_args.args[1] == str(project)
+    assert str(project) in result.warning
+
+
+def test_broad_opt_in_and_explicit_file(tmp_path):
+    project = projects(tmp_path)
+    ops = ShellFileOperations(LocalEnvironment(str(project)))
+    ops._exec = Mock(return_value=ExecuteResult(stdout='exists', exit_code=0))
+    ops._search_content = Mock(return_value=SearchResult())
+    for root, broad in ((tmp_path, True), (project / 'source.py', False)):
+        assert not ops.search('needle', str(root), allow_broad=broad).error
+        assert ops._search_content.call_args.args[1] == str(root)
+
+
+def test_rg_commands_bound_threads_and_prune(tmp_path):
+    project = projects(tmp_path)
+    ops = ShellFileOperations(LocalEnvironment(str(project)))
+    ops._exec = Mock(return_value=ExecuteResult(stdout='', exit_code=1))
+    ops._search_with_rg('needle', str(project), '*.py', 50, 0, 'content', 0, rg_executable='rg')
+    command = ops._exec.call_args.args[0]
+    assert '--threads 2' in command
+    assert 'node_modules' in command and '.git' in command
+    assert '*.py' in command
+    ops._search_files_rg('*.py', str(project), 50, 0, rg_executable='rg')
+    command = ops._exec.call_args.args[0]
+    assert '--threads 2' in command and 'node_modules' in command
+
+
+def test_concurrent_searches_have_two_slots_and_release_after_failure(tmp_path):
+    import threading
+    from concurrent.futures import ThreadPoolExecutor
+    project = projects(tmp_path)
+    lock = threading.Lock()
+    release = threading.Event()
+    entered = threading.Event()
+    active = peak = 0
+
+    def run_search(*args):
+        nonlocal active, peak
+        with lock:
+            active += 1
+            peak = max(peak, active)
+            if active == 2:
+                entered.set()
+        try:
+            assert release.wait(5)
+            return SearchResult()
+        finally:
+            with lock:
+                active -= 1
+
+    with ThreadPoolExecutor(max_workers=6) as pool:
+        pending = []
+        for _ in range(6):
+            ops = ShellFileOperations(LocalEnvironment(str(project)))
+            ops._search_scoped = run_search
+            pending.append(pool.submit(ops.search, 'needle'))
+        try:
+            assert entered.wait(3)
+            assert peak == 2
+        finally:
+            release.set()
+        assert all(not task.result().error for task in pending)
+    assert peak == 2
+
+
+def test_real_rg_project_content_and_nested_glob(tmp_path):
+    project = projects(tmp_path)
+    (project / 'src').mkdir()
+    (project / 'src' / 'nested.py').write_text('needle\n')
+    (project / 'node_modules').mkdir()
+    (project / 'node_modules' / 'noise.py').write_text('needle\n')
+    ops = ShellFileOperations(LocalEnvironment(str(project)))
+    result = ops.search('needle', str(tmp_path), file_glob='*.py')
+    assert not result.error
+    assert len(result.matches) == 2
+    assert all('node_modules' not in item.path for item in result.matches)
+    result = ops.search('src/*.py', str(project), target='files')
+    assert not result.error
+    assert len(result.files) == 1 and 'nested.py' in result.files[0]

tools/file_operations.py

@@ -50,7 +50,8 @@ from agent.file_safety import (
     get_write_denied_error,
     is_write_denied as _shared_is_write_denied,
 )
-from agent.search_policy import SEARCH_PRUNE_DIR_NAMES
+from agent.search_policy import (SEARCH_PRUNE_DIR_NAMES, SEARCH_RG_THREADS,
+                                 SEARCH_MAX_CONCURRENT, local_search_scope)
 from tools import interrupt as tool_interrupt
 
 logger = logging.getLogger(__name__)
@@ -73,6 +74,8 @@ _MACOS_TCC_PROTECTED_HOME_DIRS = (
 )
 
 
+_SEARCH_SLOTS = threading.BoundedSemaphore(SEARCH_MAX_CONCURRENT)
+
 _FILENAME_SEARCH_ADMISSION = threading.Condition()
 _ACTIVE_FILENAME_SEARCH_ROOTS: set[tuple[str, str, str]] = set()
 _FILENAME_SEARCH_WAIT_SECONDS = 0.05
@@ -3432,7 +3435,31 @@ class ShellFileOperations(FileOperations):
     def search(self, pattern: str, path: str = ".", target: str = "content",
                file_glob: Optional[str] = None, limit: int = 50, offset: int = 0,
                output_mode: str = "content", context: int = 0,
-               order: str = "discovery") -> SearchResult:
+               order: str = "discovery", allow_broad: bool = False) -> SearchResult:
+        # One admission slot covers discovery, traversal and zero-match probes.
+        # It is process-wide across file-ops instances, and interruptible.
+        while not _SEARCH_SLOTS.acquire(timeout=0.05):
+            if tool_interrupt.is_interrupted():
+                return SearchResult(error="Search interrupted while waiting for a search slot.")
+        try:
+            if tool_interrupt.is_interrupted():
+                return SearchResult(error="Search interrupted.")
+            return self._search_scoped(pattern, path, target, file_glob, limit,
+                                       offset, output_mode, context, order, allow_broad)
+        finally:
+            _SEARCH_SLOTS.release()
+
+    def _project_search_scope(self, path, allow_broad=False):
+        from tools.environments.local import LocalEnvironment, _msys_to_windows_path
+        if allow_broad or not isinstance(self.env, LocalEnvironment):
+            return path, None, None
+        cwd = getattr(self.env, "cwd", None) or self.cwd
+        return local_search_scope(_msys_to_windows_path(path), cwd, _HOME)
+
+    def _search_scoped(self, pattern: str, path: str = ".", target: str = "content",
+               file_glob: Optional[str] = None, limit: int = 50, offset: int = 0,
+               output_mode: str = "content", context: int = 0,
+               order: str = "discovery", allow_broad: bool = False) -> SearchResult:
         """
         Search for content or files.
         
@@ -3460,6 +3487,9 @@ class ShellFileOperations(FileOperations):
 
         # Expand ~ and other shell paths
         path = self._expand_path(path)
+        path, scope_notice, scope_error = self._project_search_scope(path, allow_broad)
+        if scope_error:
+            return SearchResult(error=scope_error)
         
         # Validate that the path exists before searching
         check = self._exec(f"test -e {self._escape_shell_arg(path)} && echo exists || echo not_found")
@@ -3470,7 +3500,7 @@ class ShellFileOperations(FileOperations):
             # merge the results, and report the skipped parts.
             multi = self._try_multi_path_search(
                 pattern, path, target, file_glob, limit, offset, output_mode, context,
-                order,
+                order, allow_broad,
             )
             if multi is not None:
                 return multi
@@ -3518,6 +3548,8 @@ class ShellFileOperations(FileOperations):
                 f"an unattended privacy prompt: {skipped}. Search a protected "
                 "folder directly when access is intentional."
             )
+        if scope_notice:
+            result.warning = " ".join(filter(None, [scope_notice, result.warning]))
         return result
 
     def _macos_search_exclusions(self, path: str) -> List[str]:
@@ -3587,7 +3619,7 @@ class ShellFileOperations(FileOperations):
     def _try_multi_path_search(self, pattern: str, path: str, target: str,
                                file_glob: Optional[str], limit: int, offset: int,
                                output_mode: str, context: int,
-                               order: str = "discovery") -> Optional[SearchResult]:
+                               order: str = "discovery", allow_broad: bool = False) -> Optional[SearchResult]:
         """Recover a not-found ``path`` that is really several paths in one string.
 
         Production trajectories show models passing "dir1 dir2 dir3" (or
@@ -3604,9 +3636,14 @@ class ShellFileOperations(FileOperations):
             parts = path.split()
         if len(parts) < 2:
             return None
-        existing, missing = [], []
+        existing, missing, scope_notices = [], [], []
         for p in parts:
             expanded = self._expand_path(p)
+            expanded, notice, error = self._project_search_scope(expanded, allow_broad)
+            if error:
+                return SearchResult(error=error)
+            if notice:
+                scope_notices.append(notice)
             chk = self._exec(
                 f"test -e {self._escape_shell_arg(expanded)} && echo exists || echo not_found"
             )
@@ -3641,7 +3678,7 @@ class ShellFileOperations(FileOperations):
             note += "; skipped missing: " + ", ".join(missing[:3])
             if len(missing) > 3:
                 note += f" (+{len(missing) - 3} more)"
-        warning_parts = [note]
+        warning_parts = [note, *scope_notices]
         if not merged.error:
             protected_paths = [
                 absolute
@@ -3704,7 +3741,7 @@ class ShellFileOperations(FileOperations):
 
         glob_expr = f" --glob {self._escape_shell_arg(file_glob)}" if file_glob else ""
         probe = self._exec(
-            f"{rg} -i --count-matches{glob_expr} "
+            f"{rg} --threads {SEARCH_RG_THREADS} -i --count-matches{glob_expr} {self._search_prune_glob_args()} "
             f"{self._escape_shell_arg(pattern)} {self._escape_native_tool_arg(path)} "
             f"2>/dev/null | head -50",
             timeout=30,
@@ -3723,7 +3760,7 @@ class ShellFileOperations(FileOperations):
         # files remain diagnosable, but prune heavyweight trees before rg can
         # recurse into them.
         hidden = self._exec(
-            f"{rg} --hidden --no-ignore --count-matches{glob_expr}"
+            f"{rg} --threads {SEARCH_RG_THREADS} --hidden --no-ignore --count-matches{glob_expr}"
             f" {self._search_prune_glob_args()} "
             f"{self._escape_shell_arg(pattern)} {self._escape_native_tool_arg(path)} "
             f"2>/dev/null | head -50",
@@ -3738,7 +3775,7 @@ class ShellFileOperations(FileOperations):
             )
         if re.search(r"[.\[\](){}?*+^$\\|]", pattern):
             fixed = self._exec(
-                f"{rg} -F --count-matches{glob_expr} "
+                f"{rg} --threads {SEARCH_RG_THREADS} -F --count-matches{glob_expr} {self._search_prune_glob_args()} "
                 f"{self._escape_shell_arg(pattern)} {self._escape_native_tool_arg(path)} "
                 f"2>/dev/null | head -50",
                 timeout=30,
@@ -3813,7 +3850,7 @@ class ShellFileOperations(FileOperations):
                 ))
             try:
                 return self._search_files_rg(
-                    search_pattern, path, limit, offset, order,
+                    pattern, path, limit, offset, order,
                     rg_executable=rg_executable,
                 )
             finally:
@@ -3848,6 +3885,9 @@ class ShellFileOperations(FileOperations):
         hidden_prune = (
             f" \\( -type d -name '.*'{root_exemptions} \\) -prune -o"
         )
+        names = " -o ".join(f"-name {self._escape_shell_arg(name)}"
+                              for name in sorted(SEARCH_PRUNE_DIR_NAMES))
+        hidden_prune += f" \\( -type d \\( {names} \\){root_exemptions} \\) -prune -o"
         protected_paths = [
             absolute
             for _root, _relative, absolute
@@ -3986,7 +4026,7 @@ class ShellFileOperations(FileOperations):
             f"cd {self._escape_shell_arg(scoped_common)} && " if scoped_common else ""
         )
         cmd = (
-            f"set -o pipefail; {cd_prefix}{rg} --files{sort_arg} -g {self._escape_shell_arg(glob_pattern)}"
+            f"set -o pipefail; {cd_prefix}{rg} --files{sort_arg} --threads {SEARCH_RG_THREADS} -g {self._escape_shell_arg(glob_pattern)} {self._search_prune_glob_args()}"
             f"{exclusion_args} -- {root_args} 2>/dev/null | head -n {fetch_limit}"
         )
         result = self._exec(cmd, timeout=60)
@@ -4062,7 +4102,7 @@ class ShellFileOperations(FileOperations):
         rg_executable = rg_executable or self._resolve_command("rg")
         if not rg_executable:
             return SearchResult(error="Content search requires ripgrep (rg).")
-        cmd_parts = [self._quote_executable(rg_executable), "--line-number", "--no-heading", "--with-filename"]
+        cmd_parts = [self._quote_executable(rg_executable), "--threads", str(SEARCH_RG_THREADS), "--line-number", "--no-heading", "--with-filename"]
 
         # Giant-single-line containment (ported from cline/cline#13525): a
         # match inside a serialized dump (multi-MB single-line JSON/minified
@@ -4100,6 +4140,8 @@ class ShellFileOperations(FileOperations):
         if file_glob:
             cmd_parts.extend(["--glob", self._escape_shell_arg(file_glob)])
         
+        cmd_parts.append(self._search_prune_glob_args())
+
         # Output mode handling
         if output_mode == "files_only":
             cmd_parts.append("-l")  # Files only
@@ -4230,6 +4272,8 @@ class ShellFileOperations(FileOperations):
         # Exclude hidden directories (matching ripgrep's default behavior).
         # This prevents searching inside .hub/index-cache/, .git/, etc.
         cmd_parts.append("--exclude-dir='.*'")
+        cmd_parts.extend(f"--exclude-dir={self._escape_shell_arg(name)}"
+                         for name in sorted(SEARCH_PRUNE_DIR_NAMES))
 
         # Protected-dir pruning CANNOT use --exclude-dir here: grep matches
         # exclude-dir globs against BASENAMES anywhere in the tree, so

tools/file_tools.py

@@ -2653,7 +2653,7 @@ def search_tool(pattern: str, target: str = "content", path: str = ".",
                 file_glob: str = None, limit: int = 50, offset: int = 0,
                 output_mode: str = "content", context: int = 0,
                 order: str = "discovery",
-                task_id: str = "default") -> str:
+                task_id: str = "default", allow_broad: bool = False) -> str:
     """Search for content or files."""
     try:
         offset, limit = normalize_search_pagination(offset, limit)
@@ -2670,6 +2670,7 @@ def search_tool(pattern: str, target: str = "content", path: str = ".",
             limit,
             offset,
             order,
+            allow_broad,
         )
         with _read_tracker_lock:
             task_data = _read_tracker.setdefault(task_id, {
@@ -2717,6 +2718,7 @@ def search_tool(pattern: str, target: str = "content", path: str = ".",
             pattern=pattern, path=path, target=target, file_glob=file_glob,
             limit=limit, offset=offset, output_mode=output_mode, context=context,
             order=order,
+            **({"allow_broad": True} if allow_broad else {}),
         )
         omitted = _filter_read_blocked_search_results(result, task_id)
         if hasattr(result, 'matches'):
@@ -2912,6 +2914,7 @@ SEARCH_FILES_SCHEMA = {
     "parameters": {
         "type": "object",
         "properties": {
+            "allow_broad": {"type": "boolean", "default": False, "description": "Deliberately search a home, drive or multi-project umbrella. Default scopes to the current project or asks for a scope. Does not remove pruning or CPU limits."},
             "pattern": {"type": "string", "description": "Regex pattern for content search, or glob pattern (e.g., '*.py') for file search"},
             "target": {"type": "string", "enum": ["content", "files"], "description": "'content' searches inside file contents, 'files' searches for files by name", "default": "content"},
             "path": {"type": "string", "description": "Directory or file to search in (default: current working directory)", "default": "."},
@@ -2979,7 +2982,8 @@ def _handle_search_files(args, **kw):
         pattern=args.get("pattern", ""), target=target, path=args.get("path", "."),
         file_glob=args.get("file_glob"), limit=args.get("limit", 50), offset=args.get("offset", 0),
         output_mode=args.get("output_mode", "content"), context=args.get("context", 0),
-        order=args.get("order", "discovery"), task_id=tid)
+        order=args.get("order", "discovery"), task_id=tid,
+        allow_broad=args.get("allow_broad") is True)
 
 
 def _read_file_schema_overrides():