feat(codex-bridge): change the chat model by saying so; bridge 8, IDE 1.0.0-beta.27

A model picked on the phone only arrives with a typed message that starts a turn. The bridge now
handles "modeli X yap" itself: per-chat routing, same-turn handover when a model is working,
truthful answer to "which model", and a lone "." joining a running turn no longer cuts the work.

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

.gitea/workflows/ci.yml

@@ -29,7 +29,7 @@ jobs:
     runs-on: windows-latest
     timeout-minutes: 15
     steps:
-      - uses: actions/checkout@v4
+      - uses: https://gitea.twinpay.one/yilsem/ci-actions-checkout@11d5960a326750d5838078e36cf38b85af677262 # upstream v4.4.0
         with:
           github-server-url: https://gitea.twinpay.one
       - name: Mobil TLS, profil ve baslatma regresyonlari
@@ -43,13 +43,21 @@ jobs:
           New-Item -ItemType Junction -Path node_modules -Target (Join-Path $deps 'node_modules') | Out-Null
           node node_modules/vitest/vitest.mjs run --root apps/desktop --config vitest.mobile.config.ts
           exit $LASTEXITCODE
+      - name: Codex koprusu (Python, bagimliliksiz) testleri
+        shell: powershell
+        run: |
+          $ErrorActionPreference = 'Stop'
+          $py = (Get-Command python -ErrorAction SilentlyContinue).Source
+          if ($py) { & $py -m unittest discover -s apps/desktop/assets/codex-bridge }
+          else { & py -3 -m unittest discover -s apps/desktop/assets/codex-bridge }
+          exit $LASTEXITCODE
 
   approval-gate-windows:
     runs-on: windows-latest
     timeout-minutes: 40
     steps:
       - name: Kaynagi al
-        uses: actions/checkout@v4
+        uses: https://gitea.twinpay.one/yilsem/ci-actions-checkout@11d5960a326750d5838078e36cf38b85af677262 # upstream v4.4.0
         with:
           github-server-url: https://gitea.twinpay.one
 

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

@@ -0,0 +1,68 @@
+# AITURK IDE Codex bridge
+
+Local HTTP proxy that AITURK IDE's **Settings → Codex Bağlama** runs for OpenAI Codex
+(desktop or CLI) on the same computer. Standard-library Python only; it runs on the
+agent venv's interpreter and keeps running after the IDE window closes, because
+Codex depends on it while `openai_base_url` points here.
+
+- `bridge.py`: the proxy. Subscription models go to chatgpt.com unchanged; `ide/<id>`
+  models go to the AITURK gateway configured in the agent's `config.yaml`, with the
+  key read from the agent's `.env` on every catalog refresh (never written elsewhere).
+- `ide_catalog.py`: which IDE models and combos are added to Codex's model list and
+  how they are named (`provider/model`, combos by bare name).
+  The public `/models` catalog supplies every OmniRoute chat model; a member does
+  not need a private local model allowlist. `/router/catalog` supplies only the
+  `kind` metadata used for sorting, never additional model IDs. Direct 9Router
+  entries and internal 9Router combos are excluded. Combos sort A–Z first, then
+  individual models by provider and name, including OpenAI subscription models.
+  Codex labels the first visible row `isDefault`; a saved model selection remains
+  unchanged. A failed or empty refresh keeps the last successful catalog.
+- `ozet_kopru.py`: conversation summaries are produced as plain text, so a summary made
+  by one provider stays readable after the user switches to another.
+- `gemini_context.py`, `resim_context.py`: request fixes for routed models.
+
+Run: `python bridge.py --home <data dir> --hermes-home <agent home>`. The IDE writes
+`<data dir>/bridge.json` and reads `GET /aiturk/codex-baglama/status`;
+`POST /aiturk/codex-baglama/stop` ends the process.
+
+Tests: `python -m unittest discover` in this directory.
+
+## Version 8 (IDE beta.27): changing the model by saying so
+
+Measured on a live voice chat (11 Oct 2026): a model picked on the phone reaches this machine only with a typed
+message that STARTS a turn; a message that joins a running turn (including the lone `.`) does not carry it.
+`model_gecis.py` therefore handles the change in the bridge. A short user message such as "modeli gemini flash low
+yap" (spoken through the voice assistant or typed) is matched against the model list; the chat's requests are then
+routed to that model (`model-yonlendirme.json`, keyed by `prompt_cache_key`) until Codex sends a different model
+for the chat, i.e. until the user picks another one in the list.
+
+- Idle chat: the bridge answers itself ("Sohbetin modeli artık X ..."), which also tells the voice assistant.
+- Running turn: the command is replaced by a handover note and the SAME turn continues on the new model.
+- "seçili model hangisi" / "ana model kim" is answered by the bridge with the model actually in use.
+- An ambiguous name changes nothing and lists the closest names; a name matching no model is not a command.
+- A lone `.` that joins a running turn is dropped instead of answered (answering it cut the work short).
+- Handled commands left in the history are turned into notes so a later model does not answer them again.
+
+Setting: `sesle_model` (default on).
+
+## Version 7 (IDE beta.26): external models behave like subscription models
+
+Measured on 10 Oct 2026 with the unmodified Codex binary (`codex exec`, same conversation, model switched per turn).
+
+| Area | Before | Now |
+| --- | --- | --- |
+| Context window | every added model declared 272 000 | `pencere.py`: NanoGPT's own list for `nano/*`, a local table for `cc`/`cx`/`ag`, a combo declares its smallest member, unknown = 128 000, nothing above 272 000 (the summarizer's window). Codex then compacts by itself when switching to a smaller model. |
+| Overflow | the target answered with an empty stream; Codex retried five times | `pencere.sigdir` trims the middle of oversized old parts in the outgoing copy; if it still does not fit Codex gets `context_length_exceeded`. A limit reported by the target is learned (`pencere-ogrenilen.json`). |
+| Tools | clones inherited `code_mode_only` + Responses Lite; GLM and Qwen failed 0/3 on simple tasks (empty answers, reasoning leaked into the answer) | `dis_arac_modu: "direct"` (default): classic tools. GLM 3/3, Qwen 2/3; Claude, `cx` and Gemini unchanged (6/6). `"kalip"` restores the old behaviour. |
+| Intermediate messages | external assistant messages had no `phase`; Codex treats those as final answers | `SseRewriter` stamps `commentary` / `final_answer`. Deltas are never delayed; only the item's `done` event waits for what follows. |
+| Interrupted answer | text written before a stop or an app exit was lost | `yarim.py` keeps it (memory only) when the *client* closes the stream and adds it as a note to the next user message of the same conversation, once. |
+| Images | removed from every old message for all external models | kept for vision-capable targets (user messages, newest first, 1 MB total). |
+| Summary brake | the 4th summary in 10 minutes failed the turn | three summaries in a row with no normal request in between, or eight in 10 minutes. |
+| Gateway errors | `event: error` (e.g. `upstream 402`) looked like a cut stream | permanent ones become `response.failed` with a readable message; short upstream bodies are logged. |
+| Start-up | the model list was fetched before listening; a slow gateway made the IDE give up after 10 s | window data comes from the cache at start and is refreshed in the background; the IDE waits 45 s. |
+
+Not changed: subscription models, their order and names, and everything on the voice path (`/realtime/*` passes through untouched).
+
+Settings in `bridge.json` (all optional): `dis_arac_modu`, `tasma_bekcisi`, `yarim_cevap`, `ozet_kopru.dongu_siniri`, `ozet_kopru.dongu_art_arda`.
+
+A lone `.` sent as the user's message (used to apply a model change during a voice session) is answered by the bridge itself with "<model> hazır." and never reaches a model (`nokta_karsila`, default on). Targets that reject tool calls are remembered (`aracsiz-modeller.json`) and marked "araçsız" in the picker.

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

@@ -0,0 +1,33 @@
+"""Compatibility for Gemini translators that retain only the last system turn.
+
+Only instruction-bearing text messages are folded; user/tool content is never
+promoted. Caller must scope this to the affected Gemini route. No network or IO.
+"""
+
+
+def coalesce_context(request):
+    items = request.get('input')
+    base = request.get('instructions', '')
+    if not isinstance(items, list) or not isinstance(base, str):
+        return 0
+    chunks = ['[BASE SYSTEM INSTRUCTIONS]\n' + base] if base else []
+    remaining = []
+    count = 0
+    for item in items:
+        if not isinstance(item, dict) or item.get('type', 'message') != 'message' or item.get('role') not in ('system', 'developer'):
+            remaining.append(item)
+            continue
+        content = item.get('content', '')
+        if isinstance(content, str):
+            text = content
+        elif isinstance(content, list) and all(isinstance(p, dict) and p.get('type') in ('input_text','text') and isinstance(p.get('text'), str) for p in content):
+            text = '\n'.join(p['text'] for p in content)
+        else:
+            # Unknown multimodal instruction block: do not discard or rewrite.
+            return 0
+        chunks.append('[' + item['role'].upper() + ' CONTEXT ' + str(count+1) + ']\n' + text)
+        count += 1
+    if count:
+        request['instructions'] = '\n\n'.join(chunks)
+        request['input'] = remaining
+    return count

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

@@ -0,0 +1,352 @@
+"""AITURK IDE "Codex Baglama": IDE'nin model ve combolarini Codex listesine ekler.
+
+Kaynak, IDE'nin kullandigi gecittir (config.yaml -> providers.turkservis.base_url);
+anahtar IDE'nin kendi .env dosyasindan her yenilemede okunur, bridge.json'a yazilmaz.
+
+Ac/kapat: %LOCALAPPDATA%\\TurkServis\\AITURK-IDE\\codex-baglama.json
+    {"enabled": true, "kapsam": "ide"}
+Dosya yoksa ACIK sayilir (kullanici karari, 9 Ekim 2026: varsayilan acik).
+kapsam "ide" ve "hepsi": gecidin uye katalogundaki OmniRoute sohbet modelleri.
+Yerel config'teki model adlari uye katalogunu sinirlamaz.
+"""
+import json, os, re, urllib.request
+
+import pencere
+
+# Agent home: HERMES_HOME when the IDE passes it, else the default install location.
+AGENT = os.environ.get("HERMES_HOME") or os.path.join(os.environ.get("LOCALAPPDATA", ""), "TurkServis", "AITURK-IDE", "agent")
+IDE_DIR = os.path.dirname(os.path.normpath(AGENT))
+AYAR = os.path.join(IDE_DIR, "codex-baglama.json")
+KEY_NAME = "HERMES_CUSTOM_TURKSERVIS_API_KEY"
+DEFAULT_BASE = "https://ai.turkservis.online/v1"
+
+
+def ayar_oku(yol=AYAR):
+    """Dosya yoksa ya da bozuksa varsayilan: acik, kapsam 'ide'."""
+    ayar = {"enabled": True, "kapsam": "ide"}
+    try:
+        with open(yol, encoding="utf-8") as f:
+            v = json.load(f)
+        if isinstance(v, dict):
+            if isinstance(v.get("enabled"), bool):
+                ayar["enabled"] = v["enabled"]
+            if v.get("kapsam") in ("ide", "hepsi"):
+                ayar["kapsam"] = v["kapsam"]
+    except (OSError, ValueError):
+        pass
+    return ayar
+
+
+def anahtar_oku(agent=AGENT):
+    try:
+        with open(os.path.join(agent, ".env"), encoding="utf-8", errors="replace") as f:
+            for line in f:
+                if line.startswith(KEY_NAME + "="):
+                    return line.split("=", 1)[1].strip().strip('"').strip("'")
+    except OSError:
+        pass
+    return ""
+
+
+def ide_yapilandirma(agent=AGENT):
+    """config.yaml'dan gecit adresi, varsayilan model ve tanimli model adlari.
+    Kopru bagimliliksiz calistigi icin YAML'in yalniz bu bolumu satir satir okunur."""
+    base, varsayilan, adlar = DEFAULT_BASE, "", []
+    try:
+        with open(os.path.join(agent, "config.yaml"), encoding="utf-8", errors="replace") as f:
+            lines = f.read().splitlines()
+    except OSError:
+        return base, varsayilan, adlar
+    bolum = saglayici = None
+    modellerde = False
+    for line in lines:
+        if not line.strip() or line.lstrip().startswith("#"):
+            continue
+        girinti = len(line) - len(line.lstrip(" "))
+        metin = line.strip()
+        if girinti == 0:
+            bolum = metin.rstrip(":"); saglayici = None; modellerde = False
+            continue
+        if bolum == "model" and girinti == 2:
+            if metin.startswith("default:"):
+                varsayilan = metin.split(":", 1)[1].strip().strip("'\"")
+            continue
+        if bolum != "providers":
+            continue
+        if girinti == 2:
+            saglayici = metin.rstrip(":"); modellerde = False
+        elif saglayici == "turkservis" and girinti == 4:
+            modellerde = metin == "models:"
+            if metin.startswith("base_url:"):
+                base = metin.split(":", 1)[1].strip().strip("'\"") or base
+        elif saglayici == "turkservis" and modellerde and girinti == 6:
+            ad = re.split(r":\s*(\{|$)", metin)[0].strip().strip("'\"")
+            if ad:
+                adlar.append(ad)
+    return base.rstrip("/"), varsayilan, adlar
+
+
+AITURK_EKI = " (AITURK)"
+# Gecidin kisa saglayici kodu -> kullanicinin gormek istedigi kod (10 Ekim 2026: "agy/gemini").
+_SAGLAYICI_KISA = {"ag": "agy"}
+# Saglayici kodu zaten soyledigi icin model adinin basinda tekrar edilmeyen uretici adi ("cc/opus-5-5").
+_TEKRAR = ("claude-",)
+DUSUNMESIZ = "no-think-"
+
+
+def kisa_ad(ad):
+    """Gecit onekleri ("OmniRoute · ", "9Router · ", "9R · ") ve aradaki saglayici halkalari atilir:
+    "nano/qwen/qwen3.8-27b" -> "nano/qwen3.8-27b", "9R · ag/gemini-3.8-flash" -> "ag/gemini-3.8-flash",
+    combo adi oldugu gibi kalir. Kullanici karari (10 Ekim 2026): "9R" yazilmaz."""
+    ad = (ad or "").split(" · ")[-1].strip()
+    parcalar = [p for p in ad.split("/") if p]
+    if len(parcalar) <= 2:
+        return "/".join(parcalar) or ad
+    return parcalar[0] + "/" + parcalar[-1]
+
+
+def gorunen_ad(kimlik, ad, tur="model"):
+    """Secicide gorunen ad (kullanici karari, 10 Ekim 2026): combo yalniz kendi adiyla; tek model
+    "saglayici/model" kalibinda, kisa ve surumlu: "9R · cc/claude-opus-5-5" -> "cc/opus-5-5",
+    "9R · ag/gemini-3.8-flash-high" -> "agy/gemini-3.8-flash-high", "Agnes 2.0 Flash" (agnes-agnes-2.0-flash)
+    -> "agnes/agnes-2.0-flash", "kurnaz" (bekci-kurnaz) -> "bekci/kurnaz". Dusunmesiz kopya asil
+    saglayicisiyla gorunur: "no-think/claude-opus-5-5" -> "cc/opus-5-5 (no-think)"."""
+    yalin = kisa_ad(ad)
+    if tur == "combo":
+        return yalin
+    kim, ek = kimlik or "", ""
+    if kim.startswith(DUSUNMESIZ):
+        kim, ek = kim[len(DUSUNMESIZ):], " (no-think)"
+    if kim.startswith("9router-"):
+        kim = kim[len("9router-"):]
+    saglayici, _, model = yalin.partition("/")
+    if not model or ek:
+        kod, _, kalan = kim.partition("-")
+        if not kod or not kalan:
+            return yalin
+        saglayici, model = kod, model or kalan
+    model = model.replace(" ", "-")
+    for tekrar in _TEKRAR:
+        if model.lower().startswith(tekrar) and len(model) > len(tekrar):
+            model = model[len(tekrar):]
+    return f"{_SAGLAYICI_KISA.get(saglayici.lower(), saglayici)}/{model}{ek}"
+
+
+def adlandir(girdiler, dolu=(), turler=None):
+    """[(kimlik, tam_ad)] -> {kimlik: gorunen_ad}. Kisa adlar cakisirsa aradaki halkalar geri konur;
+    yine cakisirsa kimligin sonu eklenir. `dolu`: baska kaynaktan gelen, zaten kullanilan adlar.
+    `turler` ({kimlik: "combo"|"model"}) verilirse adlar gorunen_ad kuraliyla yazilir."""
+    if turler is None:
+        kisa = {k: kisa_ad(a) for k, a in girdiler}
+    else:
+        kisa = {k: gorunen_ad(k, a, turler.get(k, "model")) for k, a in girdiler}
+    tam = {k: (a or "").split(" · ")[-1].strip() for k, a in girdiler}
+    sayac = {}
+    for v in list(kisa.values()) + list(dolu):
+        sayac[v.lower()] = sayac.get(v.lower(), 0) + 1
+    sonuc, kullanilan = {}, {d.lower() for d in dolu}
+    for k, _ in girdiler:
+        ad = kisa[k] if sayac[kisa[k].lower()] == 1 else tam[k]
+        if ad.lower() in kullanilan:
+            ad = f"{ad} [{k[-8:]}]"
+        kullanilan.add(ad.lower())
+        sonuc[k] = ad
+    return sonuc
+
+
+def sec(data, tanimli=(), kapsam="ide", turler=None):
+    """Gecidin uye katalogundan girdiler: [{'id','ad','kind'}], sirali ve tekrarsiz.
+    Yalniz sohbet modelleri; resim/ses/video/embedding uretenler eklenmez."""
+    turler = turler or {}
+    secilen, gorulen = [], set()
+    for m in data:
+        mid = m.get("id") or ""
+        ts = m.get("turkservis") or {}
+        if not mid or mid in gorulen or "chat" not in (ts.get("capabilities") or ["chat"]):
+            continue
+        gorunen = ts.get("display_name") or mid
+        kind = turler.get(mid) or ts.get("kind") or "model"
+        # Tek uye yolu: 9Router -> OmniRoute -> TurkServis -> Codex.
+        # Dogrudan 9Router satirlari ayni modelin ikinci kopyasi olarak eklenmez.
+        if ts.get("source") != "omniroute":
+            continue
+        # Combo adi biciminden tahmin edilmez; duz adli Agnes/Bekci modelleri de vardir.
+        if kind == "combo" and mid.lower().startswith("9router-"):
+            continue
+        gorulen.add(mid)
+        secilen.append({"id": mid, "ad": gorunen, "kind": kind, "sira": ts.get("order") or 0,
+                        "yol": str(m.get("description") or "").split(" · ")[-1].strip()})
+    secilen.sort(key=lambda s: (s["sira"], s["id"]))
+    # Gecit ayni adin ikinci yoluna "ad (2)" der; birincisi listede yoksa sayac anlamsizdir.
+    adlar = {s["ad"].split(" · ")[-1].strip().lower() for s in secilen}
+    for s in secilen:
+        taban = re.sub(r" \(\d+\)$", "", s["ad"])
+        if taban != s["ad"] and taban.split(" · ")[-1].strip().lower() not in adlar:
+            adlar.add(taban.split(" · ")[-1].strip().lower())
+            s["ad"] = taban
+    return [{"id": s["id"], "ad": s["ad"], "kind": s["kind"], "yol": s["yol"]} for s in secilen]
+
+
+def sirala_codex(modeller, ekler):
+    """Ozgun abonelik modelleri oldugu gibi kalir: sirasi, priority degeri ve adi degismez,
+    listenin basinda durur. Ek modeller onlarin ARKASINA eklenir: combo A-Z, sonra
+    saglayici A-Z / model A-Z. Ozgun bir modelle ayni adi tasiyan ek model " (AITURK)"
+    ekiyle ayirt edilir; secicide ozgunun yerine gecmis gibi gorunmez.
+    Kimlik ve yetenek alanlari korunur; kayitli model secimine dokunulmaz."""
+    bilgiler = {m["slug"]: m for m in ekler}
+    ozgunler = [m for m in modeller if m.get("slug", "") not in bilgiler]
+    ek_modeller = [m for m in modeller if m.get("slug", "") in bilgiler]
+    def yalin(ad):  # "GPT-6-1-Sol" ile "GPT-6.1-Sol" ayni ad sayilir
+        return re.sub(r"[^0-9a-z]+", "", (ad or "").casefold())
+
+    ozgun_adlar = {yalin(m.get("display_name") or m.get("slug", "")) for m in ozgunler}
+
+    def anahtar(m):
+        slug = m.get("slug", "")
+        bilgi = bilgiler.get(slug, {})
+        ad = kisa_ad(m.get("display_name") or slug)
+        if bilgi.get("kind") == "combo":
+            return (0, ad.casefold(), "", slug)
+        if slug.startswith("ide/"):
+            mid = slug[len("ide/"):]
+            if mid.startswith("9router-"):
+                mid = mid[len("9router-"):]
+            saglayici, _, model = ad.partition("/")
+            if not model:
+                saglayici, _, _ = mid.partition("-")
+                model = ad
+        else:
+            saglayici, model = "OpenAI", ad
+        return (1, saglayici.casefold(), model.casefold(), slug)
+
+    ek_modeller.sort(key=anahtar)
+    taban = max([m.get("priority") or 0 for m in ozgunler], default=-1) + 1
+    for n, model in enumerate(ek_modeller):
+        model["priority"] = taban + n
+        ad = model.get("display_name") or model.get("slug", "")
+        if yalin(ad) in ozgun_adlar:
+            model["display_name"] = f"{ad}{AITURK_EKI}"
+    modeller[:] = ozgunler + ek_modeller
+
+
+# ---- Secicide model adinin altindaki satir ----
+# Telefonda bu satir tek satirdir ve yaklasik 30 karakterde kesilir (kullanici ekran goruntusu,
+# 10 Ekim 2026); en ayirt edici bilgi basa yazilir, ad tekrar edilmez.
+ACIKLAMA_SINIRI = 30
+KUCUK_PENCERE = 100_000      # bunun altindaki pencere alt satirda yazilir
+_AILE = (("opus", "opus"), ("sonnet", "sonnet"), ("haiku", "haiku"), ("astra", "astra"), ("terra", "terra"),
+         ("luna", "luna"), ("sol", "sol"), ("gemini", "gemini"), ("qwen", "qwen"), ("glm", "glm"),
+         ("abliterated", "abliterated"), ("deepseek", "deepseek"), ("llama", "llama"), ("gemma", "gemma"))
+_SAGLAYICI = {"cc": "Claude", "cx": "Codex", "ag": "Antigravity", "agy": "Antigravity", "nano": "NanoGPT", "hf": "HuggingFace",
+              "huggingface": "HuggingFace", "agnes": "Agnes", "bekci": "Bekçi"}
+_SANSURSUZ = re.compile(r"uncensored|abliterat|obliterat|derestrict|heretic|unshackled", re.I)
+
+
+def kisa_model(ad):
+    """"cc/claude-opus-5-5" -> "opus", "nano/z-ai/glm-5.3-flash-uncensored" -> "glm"; bilinmeyen ad "?"."""
+    if not ad:
+        return "?"
+    son = ad.split("/")[-1].split(":")[0].lower()
+    parcalar = [p for p in re.split(r"[^a-z]+", son) if p]
+    for anahtar, kisa in _AILE:
+        if anahtar in parcalar:
+            return kisa
+    return (parcalar[0] if parcalar else son) or "?"
+
+
+def _yapraklar(dugum, derinlik=0):
+    """Sirali (priority) zinciri duz model listesine acar; ic takim kendi uyeleriyle yer alir."""
+    if not isinstance(dugum, dict) or derinlik > 6:
+        return ["?"]
+    if dugum.get("kind") != "combo":
+        return [kisa_model(dugum.get("model"))]
+    cikti = []
+    for uye in dugum.get("members") or []:
+        cikti.extend(_yapraklar(uye, derinlik + 1))
+    return cikti or ["?"]
+
+
+def _sigdir(onek, adlar, ayrac):
+    """Sinira sigdigi kadar ad yazar, kalani "+N" ile sayar."""
+    tekil = [a for i, a in enumerate(adlar) if i == 0 or a != adlar[i - 1]]
+    for adet in range(len(tekil), 0, -1):
+        kalan = len(tekil) - adet
+        metin = onek + ayrac.join(tekil[:adet]) + (f" +{kalan}" if kalan else "")
+        if len(metin) <= ACIKLAMA_SINIRI or adet == 1:
+            return metin
+    return onek.rstrip(": ")
+
+
+def aciklama(kimlik, ad, tur, kayit=None, bilgi=None):
+    """Model adinin altinda gorunecek kisa satir. kayit: gecidin /router/catalog girdisi (yoksa None).
+    Takim -> uyeleri; sirali yedek -> sirasi; tek model -> saglayicisi ve adindan okunan ozellikleri.
+    bilgi (pencere.coz sonucu): Codex'te isi etkileyen iki uyari one yazilir: kucuk baglam ("32K")
+    ve arac cagiramayan model ("araçsız")."""
+    if tur == "combo":
+        topoloji = (kayit or {}).get("topology") or {}
+        uyeler = topoloji.get("members") or []
+        if topoloji.get("strategy") == "round-robin":
+            return f"Dönüşümlü: {len(uyeler)} üye"
+        takim = topoloji if topoloji.get("strategy") == "fusion" else None
+        if takim is None and uyeler and isinstance(uyeler[0], dict) and uyeler[0].get("strategy") == "fusion":
+            takim = uyeler[0]
+        if takim is not None:
+            return _sigdir("Takım: ", [kisa_model(u.get("model")) for u in takim.get("members") or []], "+")
+        if uyeler:
+            return _sigdir("Sıralı: ", _yapraklar(topoloji), ">")
+        return "Takım"
+    kisa = gorunen_ad(kimlik, ad, "model")
+    kod = kisa.split("/")[0].lower() if "/" in kisa else (kimlik or "").split("-")[0].lower()
+    parcalar = [_SAGLAYICI.get(kod, kod) or "Tek model"]
+    if bilgi and bilgi.get("pencere") and bilgi["pencere"] < KUCUK_PENCERE:
+        parcalar.append(pencere.kisa(bilgi["pencere"]))
+    if bilgi and bilgi.get("arac") is False:
+        parcalar.append("araçsız")
+    if _SANSURSUZ.search(kisa) or _SANSURSUZ.search(kimlik or ""):
+        parcalar.append("sansürsüz")
+    if "thinking" in (kisa + " " + (kimlik or "")).lower():
+        parcalar.append("düşünen")
+    if len(parcalar) == 1:
+        parcalar.insert(0, "Tek model")
+    while len(parcalar) > 1 and len(" · ".join(parcalar)) > ACIKLAMA_SINIRI:
+        parcalar.pop()          # sona yazilan en az onemli ozellik duser; kelime ortasindan kesilmez
+    return " · ".join(parcalar)[:ACIKLAMA_SINIRI]
+
+
+def yukle(ua="AstraBridge/1.0 (codex)", timeout=30, home=None, ag=True):
+    """Donus: (durum, base_url, anahtar, girdiler). durum: 'kapali' | 'anahtar-yok' | 'tamam'.
+    Ag hatasinda istisna atar; cagiran son listeyi korur. home: koprunun veri klasoru (pencere onbellegi).
+    Her girdi "pencere" (ilan edilecek baglam penceresi), "gorsel" ve "arac" alanlarini tasir."""
+    ayar = ayar_oku()
+    if not ayar["enabled"]:
+        return "kapali", "", "", []
+    anahtar = anahtar_oku()
+    if not anahtar:
+        return "anahtar-yok", "", "", []
+    base, varsayilan, adlar = ide_yapilandirma()
+    req = urllib.request.Request(base + "/models", headers={"Authorization": f"Bearer {anahtar}", "User-Agent": ua})
+    with urllib.request.urlopen(req, timeout=timeout) as resp:
+        data = json.load(resp).get("data")
+    if not isinstance(data, list) or not data:
+        raise ValueError("Gecit bos veya gecersiz model katalogu dondurdu")
+    req = urllib.request.Request(base + "/router/catalog", headers={"Authorization": f"Bearer {anahtar}", "User-Agent": ua})
+    with urllib.request.urlopen(req, timeout=timeout) as resp:
+        metadata = json.load(resp).get("models")
+    if not isinstance(metadata, list) or not metadata:
+        raise ValueError("Gecit model turlerini dondurmedi")
+    # Bu ucta uye listesinde olmayan ic kayitlar da bulunur. Yalniz tur bilgisi alinir;
+    # modele erisim listesi her zaman /models yanitidir.
+    turler = {m["id"]: m["kind"] for m in metadata if m.get("id") and m.get("kind") in ("combo", "model")}
+    girdiler = sec(data, adlar + [varsayilan], ayar["kapsam"], turler)
+    if not girdiler:
+        raise ValueError("Gecitte kullanilabilir OmniRoute sohbet modeli yok")
+    kayitlar = {m["id"]: m for m in metadata 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)
+        g["pencere"], g["gorsel"], g["arac"], g["pencere_kaynak"] = (bilgi["pencere"], bilgi["gorsel"],
+                                                                     bilgi["arac"], bilgi["kaynak"])
+        g["aciklama"] = aciklama(g["id"], g["ad"], g["kind"], kayitlar.get(g["id"]), bilgi)
+    return "tamam", base, anahtar, girdiler

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

@@ -0,0 +1,259 @@
+"""Sesle ya da yaziyla "modeli sunu yap" komutu ve sohbet basina model yonlendirmesi (10 Ekim 2026).
+
+Olcum (sesli sohbet 01a12780): telefonda secilen model bilgisayara yalnizca YENI TUR baslatan yazili mesajla
+ulasiyor. Calisan tura eklenen mesaj (nokta dahil) secimi tasimiyor; dort denemenin ucunde secim kayboldu.
+Codex'in pencereler arasi kanali da sohbet bir pencerede acik degilse istegi kabul etmiyor. Bu yuzden degisiklik
+koprude yapilir: kullanici "modeli gemini flash low yap" der (sesli asistan bunu her soz gibi ana modele iletir),
+kopru cumleyi tanir, o sohbetin isteklerini secilen modele yonlendirir ve cevabi kendisi verir.
+
+- Model bostayken: kopru yerel cevap verir ("Sohbetin modeli artik ...").
+- Model calisirken (tur ortasi): komut mesaji kisa bir devir notuna cevrilir ve AYNI tur yeni modelle surer;
+  yarim kalan is kesilmez, yeni model kaldigi yerden devam eder.
+- Kullanici sonradan listeden baska model secerse (Codex'in gonderdigi ad degisir) yonlendirme kendiliginden kalkar.
+
+Ad bulunamazsa mesaj komut sayilmaz, modele oldugu gibi gider. Birden cok aday varsa degisiklik yapilmaz, adaylar sorulur.
+"""
+import json
+import os
+import re
+import threading
+import time
+
+DOSYA = "model-yonlendirme.json"
+OMUR_SN = 7 * 24 * 3600
+EN_COK_KAYIT = 200
+EN_COK_KELIME = 14
+_KILIT = threading.Lock()
+
+_TR = str.maketrans("çğıöşüâîû", "cgiosuaiu")
+FIILLER = ("gec", "degis", "yap", "sec", "kullan", "cevir", "olsun", "ayarla")
+SORU = ("hangi", "hangisi", "kim", "kimdir")
+ATLA = {"model", "modeli", "modelini", "modele", "modeline", "modelin", "modelle", "modeller", "su", "bu", "o", "bir",
+        "olarak", "ile", "lutfen", "artik", "ana", "sohbet", "sohbetin", "chat", "chatin", "chatte", "simdi", "hadi",
+        "bana", "icin", "de", "da", "ve", "mi", "misin", "musun", "mu", "yeni", "diger", "baska", "olan", "codex",
+        "ya", "e", "a", "i", "u", "yi", "ye", "na", "ne", "nu", "seni", "sen", "biz", "onu", "ona"}
+# Konusmadan yaziya ceviride sik gorulen yazimlar -> model adindaki parca
+TAKMA = {"cloud": "claude", "klod": "claude", "klaud": "claude", "claud": "claude", "opus": "opus", "opüs": "opus",
+         "cemini": "gemini", "jemini": "gemini", "cemin": "gemini", "flas": "flash", "fles": "flash",
+         "kuven": "qwen", "kiven": "qwen", "kuen": "qwen", "kven": "qwen", "kodeks": "codex",
+         "dusuk": "low", "yuksek": "high", "orta": "medium", "sonet": "sonnet", "haiku": "haiku",
+         "sansursuz": "uncensored", "ansansird": "uncensored", "dusunen": "thinking", "dusunmeli": "thinking",
+         "ciptii": "gpt", "cipiti": "gpt", "gipiti": "gpt"}
+
+
+# Listede kisa yazilan saglayici -> konusurken soylenen ad
+SAGLAYICI = {"cc": ("claude",), "agy": ("gemini", "antigravity"), "ag": ("gemini", "antigravity"), "cx": ("codex", "gpt")}
+
+
+def duz(metin):
+    return str(metin or "").lower().translate(_TR)
+
+
+def parcala(metin):
+    """Harf ve rakam obeklerine ayirir: "agy/gemini-3.8-flash-low" -> agy gemini 3 8 flash low."""
+    return [TAKMA.get(p, p) for p in re.findall(r"[a-z]+|\d+", duz(metin))]
+
+
+def son_sira(girdi):
+    """Son kullanici mesajinin sirasi. Arkasindaki talimat (developer/system) mesajlari atlanir: kancalar
+    kullanici mesajinin ardina baglam ekler (olcum 10 Ekim 2026). Baska bir oge varsa -1."""
+    if not isinstance(girdi, list):
+        return -1
+    for i in range(len(girdi) - 1, -1, -1):
+        oge = girdi[i]
+        if isinstance(oge, dict) and oge.get("type", "message") == "message":
+            if oge.get("role") == "user":
+                return i
+            if oge.get("role") in ("developer", "system"):
+                continue
+        return -1
+    return -1
+
+
+def son_kullanici_metni(req):
+    """(metin, sira, sesli). Son girdi kullanici metin mesaji degilse (None, -1, False).
+    Sesli aktarimda (<realtime_delegation>) yalnizca <input> icindeki soz alinir."""
+    girdi = req.get("input")
+    sira = son_sira(girdi)
+    if sira < 0:
+        return None, -1, False
+    son = girdi[sira]
+    icerik = son.get("content")
+    if isinstance(icerik, str):
+        metin = icerik
+    elif isinstance(icerik, list) and icerik and all(isinstance(p, dict) and p.get("type") in ("input_text", "text")
+                                                    for p in icerik):
+        metin = "".join(str(p.get("text") or "") for p in icerik)
+    else:
+        return None, -1, False
+    m = re.search(r"<realtime_delegation>.*?<input>(.*?)</input>", metin, re.S)
+    if m:
+        return m.group(1).strip(), sira, True
+    if "<" in metin and ">" in metin:
+        return None, -1, False            # baska bir sarmalli sistem mesaji; komut aranmaz
+    return metin.strip(), sira, False
+
+
+def komut_coz(metin):
+    """None | {"tur": "gec", "ad": [parcalar]} | {"tur": "sor"}."""
+    kelimeler = re.findall(r"[a-z0-9]+", duz(metin))
+    if not kelimeler or len(kelimeler) > EN_COK_KELIME or not any(k.startswith("model") for k in kelimeler):
+        return None
+    if len(kelimeler) <= 8 and any(k in SORU for k in kelimeler):
+        return {"tur": "sor"}
+    fiil = [k for k in kelimeler if k.startswith(FIILLER) and not k.startswith("model")]
+    if fiil:
+        ad = [TAKMA.get(k, k) for k in kelimeler if k not in ATLA and k not in fiil]
+        ad = [p for k in ad for p in re.findall(r"[a-z]+|\d+", k)]
+        return {"tur": "gec", "ad": ad} if ad else None
+    return None
+
+
+def _uyar(sorgu, parca):
+    """Turkce ek almis soz ("geminiye", "opusa") model parcasiyla baslar."""
+    if sorgu == parca:
+        return True
+    return len(parca) >= 3 and sorgu.startswith(parca) and len(sorgu) - len(parca) <= 4 and not sorgu.isdigit()
+
+
+def eslestir(ad, modeller):
+    """ad: sorgu parcalari; modeller: [(slug, gorunen ad)].
+    Doner: {"slug", "ad"} (tek aday) | {"adaylar": [gorunen adlar]} (belirsiz) | None (ad bir modele benzemiyor)."""
+    if not ad:
+        return None
+    puanli = []
+    for slug, gorunen in modeller:
+        parcalar = parcala(gorunen) or parcala(slug)
+        kume = set(parcalar) | set(parcala(slug))
+        for kisa, uzunlar in SAGLAYICI.items():
+            if kisa in kume:
+                kume.update(uzunlar)
+        tutan = sum(1 for s in ad if any(_uyar(s, p) for p in kume))
+        harf = sum(1 for s in ad if not s.isdigit() and any(_uyar(s, p) for p in kume))
+        if harf:                                    # yalniz rakam tutmasi ("3", "5") esleme sayilmaz
+            puanli.append((tutan, -len(parcalar), slug, gorunen))
+    if not puanli:
+        return None
+    en = max(p[0] for p in puanli)
+    if en < len(ad) and en < max(2, (len(ad) * 2 + 2) // 3):
+        return None                                 # sozun cogu hicbir modele uymuyor: komut degil
+    iyi = sorted((p for p in puanli if p[0] == en), key=lambda p: (-p[1], p[3]))
+    if len(iyi) == 1 or iyi[0][1] != iyi[1][1]:
+        return {"slug": iyi[0][2], "ad": iyi[0][3]}
+    return {"adaylar": [p[3] for p in iyi[:4]]}
+
+
+_ARAC = {"function_call", "function_call_output", "custom_tool_call", "custom_tool_call_output", "reasoning",
+         "local_shell_call", "local_shell_call_output", "tool_search_call", "tool_search_output"}
+
+
+def tur_ortasi(req, sira):
+    """Mesaj calisan bir turun icine mi dustu? Geriye dogru, kullanici/talimat mesajlarini atlayarak bakilir:
+    once arac ogesi ya da ara (commentary) mesaj gelirse tur suruyordur; once son cevap gelirse tur yeni baslamistir."""
+    girdi = req.get("input") or []
+    for oge in reversed(girdi[:max(sira, 0)]):
+        if not isinstance(oge, dict):
+            continue
+        tur = oge.get("type", "message")
+        if tur in _ARAC:
+            return True
+        if tur == "message":
+            if oge.get("role") == "assistant":
+                return oge.get("phase") == "commentary"
+            continue
+    return False
+
+
+def metni_degistir(req, sira, yeni):
+    """sira'daki kullanici mesajinin metnini yeni ile degistirir (sesli aktarimda yalnizca <input> icini)."""
+    oge = req["input"][sira]
+    icerik = oge.get("content")
+    eski = icerik if isinstance(icerik, str) else "".join(str(p.get("text") or "") for p in icerik)
+    if "<realtime_delegation>" in eski:
+        metin = re.sub(r"(<input>).*?(</input>)", lambda m: m.group(1) + yeni + m.group(2), eski, count=1, flags=re.S)
+    else:
+        metin = yeni
+    oge["content"] = metin if isinstance(icerik, str) else [{"type": icerik[0].get("type", "input_text"), "text": metin}]
+
+
+def gecmisi_temizle(req, modeller):
+    """Gecmisteki (son mesaj disindaki) islenmis "modeli X yap" komutlarini kisa nota cevirir; yoksa sonraki
+    model ayni cumleyi yeniden gorup "modeli ben degistiremem" diye cevap veriyor (olcum 11 Ekim 2026).
+    Doner: degistirilen mesaj sayisi."""
+    girdi = req.get("input")
+    if not isinstance(girdi, list):
+        return 0
+    son = son_sira(girdi)
+    n = 0
+    for i, oge in enumerate(girdi):
+        if i == son or not (isinstance(oge, dict) and oge.get("type", "message") == "message" and oge.get("role") == "user"):
+            continue
+        metin, _, _ = son_kullanici_metni({"input": [oge]})
+        if not metin or "model" not in duz(metin) or metin.startswith("[Köprü notu"):
+            continue
+        komut = komut_coz(metin)
+        sonuc = eslestir(komut["ad"], modeller) if komut and komut["tur"] == "gec" else None
+        if sonuc and "slug" in sonuc:
+            metni_degistir(req, i, f"[Köprü notu: kullanıcı burada sohbetin modelini {sonuc['ad']} olarak değiştirdi; "
+                                   "değişiklik köprü tarafından yapıldı, senin bir şey yapman gerekmiyor.]")
+            n += 1
+    return n
+
+
+def devir_notu(yeni_ad, eski_ad):
+    return (f"[Köprü notu: kullanıcı bu sohbetin modelini değiştirdi. Önceki model {eski_ad} idi; şu andan itibaren "
+            f"cevap veren model sensin ({yeni_ad}). Yarım kalan işi kaldığı yerden sürdür, baştan başlama. "
+            f"Cevabının ilk cümlesinde kısaca \"{yeni_ad} olarak devam ediyorum\" de.]")
+
+
+class Yonlendirme:
+    """sohbet anahtari -> {"gorulen": Codex'in gonderdigi ad, "hedef": yonlenen ad, "zaman"}; diske yazilir."""
+
+    def __init__(self, home):
+        self.yol = os.path.join(home, DOSYA) if home else None
+        self.veri = {}
+        if self.yol:
+            try:
+                with open(self.yol, encoding="utf-8") as f:
+                    okunan = json.load(f)
+                if isinstance(okunan, dict):
+                    self.veri = {k: v for k, v in okunan.items() if isinstance(v, dict) and v.get("hedef")}
+            except (OSError, ValueError):
+                pass
+
+    def _yaz(self):
+        if not self.yol:
+            return
+        try:
+            gecici = self.yol + ".tmp"
+            with open(gecici, "w", encoding="utf-8") as f:
+                json.dump(self.veri, f, ensure_ascii=False)
+            os.replace(gecici, self.yol)
+        except OSError:
+            pass
+
+    def al(self, sohbet, gelen, simdi=None):
+        """Bu sohbet icin yonlenen ad; yoksa None. Codex baska bir ad gonderiyorsa (kullanici listeden yeni
+        model secti) ya da kayit eskidiyse yonlendirme silinir."""
+        simdi = simdi or time.time()
+        with _KILIT:
+            k = self.veri.get(sohbet)
+            if not k:
+                return None
+            if k.get("gorulen") != gelen or simdi - float(k.get("zaman") or 0) > OMUR_SN:
+                del self.veri[sohbet]
+                self._yaz()
+                return None
+            return k["hedef"]
+
+    def koy(self, sohbet, gelen, hedef, simdi=None):
+        simdi = simdi or time.time()
+        with _KILIT:
+            if hedef == gelen:
+                self.veri.pop(sohbet, None)
+            else:
+                self.veri[sohbet] = {"gorulen": gelen, "hedef": hedef, "zaman": simdi}
+                if len(self.veri) > EN_COK_KAYIT:
+                    for eski in sorted(self.veri, key=lambda a: self.veri[a].get("zaman") or 0)[:-EN_COK_KAYIT]:
+                        del self.veri[eski]
+            self._yaz()

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

@@ -0,0 +1,313 @@
+"""Sikistirma (ozet) bagdastiricisi (6 Ekim 2026, kart a-grubu-bakim-20261006-0417).
+
+Codex 0.160.0 "remote compaction v2" kullanir: girdinin sonuna {"type": "compaction_trigger"} koyar ve yanitta tam bir
+{"type": "compaction", "encrypted_content": ...} ogesi bekler. Gercek olcum (raporlar/sesli-kopru-kanit-20261006/sik1, sik2):
+  * 9Router modelleri bu ogeyi uretemez -> "remote compaction v2 expected exactly one compaction output item, got 0",
+    tur hata verir (kucuk modele geciste ve 9Router modelinde esik asilinca).
+  * OpenAI'nin urettigi sifreli ozet 9Router modelince okunamaz -> kararlar/gerekceler kaybolur.
+
+Bu modul:
+  1. 9Router'a giden sikistirma isteginde ozeti duz metin olarak ayni (ya da bridge.json ozet_kopru.model ile secilen)
+     modele yazdirir ve Codex'in bekledigi "compaction" ogesine sarar (encrypted_content = ISARET + base64(metin)).
+  2. Koprunun urettigi ozet ogelerini her giden istekte duz metin kullanici mesajina acar (hangi saglayiciya giderse).
+  3. OpenAI'nin sifreli ozeti 9Router modeline gidecekse, OpenAI'ye bir kez "bu ozeti duz metne dok" diye sorar,
+     sonucu diske onbellekler ve onu gonderir; olmazsa durust bir not koyar (sessiz kayip yok).
+OpenAI -> OpenAI sikistirmasi oldugu gibi (yerlesik) kalir.
+Kapatmak: bridge.json  "ozet_kopru": {"enabled": false}
+"""
+import base64, hashlib, json, os, re
+
+ISARET = "ASTRABRIDGE-OZET-1:"
+OZET_BASLIK = "<onceki_konusma_ozeti>"
+OZET_BITIS = "</onceki_konusma_ozeti>"
+
+OZET_ISTEMI = """BAGLAM KONTROL NOKTASI (bu mesaj kullanicidan degil, kopru altyapisindan): Bu konusma baglam sinirina yaklastigi icin ozetlenip baska bir modele devredilecek. Simdi arac CAGIRMA; yalniz asagidaki ozeti yaz. Ozeti okuyacak model bu konusmayi goremeyecek, yalniz senin yazdigini gorecek; bu yuzden kisa tutmak icin bilgi atma. Bu ozet istegini kullanicinin istegi gibi ozetleme.
+
+Kurallar:
+- Kullanicinin ve konusmanin kullandigi etiket, kimlik ve adlari (ornek: "KARAR-1", kart/is numaralari, dosya adlari, model adlari) HARFI HARFINE koru ve her bilgiyi kendi etiketiyle yaz.
+- Sayilari, tarihleri, yollari, komutlari ve onemli ozgun cumleleri degistirmeden aktar.
+- Uydurma; emin olmadigin seyi "dogrulanmadi" diye isaretle. Sifre, anahtar ve gizli degerleri yazma.
+
+Su basliklarla, madde madde ve somut yaz:
+1. KULLANICININ ISTEGI VE HEDEF: kullanicinin kendi sozleriyle ne istedigi, kabul olcutleri, kisitlar.
+2. KARARLAR VE GEREKCELERI: verilen her karar ve neden verildigi (etiketleriyle); reddedilen secenekler ve nedeni.
+3. YAPILANLAR VE ONEMLI SONUCLAR: degisen dosyalar, calistirilan komutlar ve gercek ciktilari, test/olcum sonuclari, dogrulanan ve dogrulanamayan seyler.
+4. ACIK ISLER VE SIRADAKI ADIM: bitmemis isler, bekleyen sorular/onaylar, bir sonraki somut adim.
+5. KULLANICI TERCIHLERI VE UYARILAR: kalici talimatlar, yapilmamasi istenenler, bilinen tuzaklar ve hatalar.
+6. GEREKLI BASVURULAR: yollar, adresler, kart/is numaralari, model ve ayar adlari."""
+
+COZ_ISTEMI = ("Yukaridaki sikistirilmis konusma ozetinin icerigini, bu konusmayi hic gormemis baska bir modelin isi "
+              "surdurebilmesi icin eksiksiz ve ayrintili DUZ METIN olarak yaz: kullanicinin istegi, kararlar ve gerekceleri, "
+              "yapilanlar ve onemli sonuclar, acik isler ve siradaki adim, kullanici tercihleri, gerekli yollar/kimlikler. "
+              "Arac cagirma, yorum ekleme, uydurma. Sifre ve anahtar yazma.")
+
+OKUNAMADI_NOTU = ("(Kopru notu: Bu noktadan onceki konusma, onceki modelin sifreli ozetinde duruyor ve bu modele "
+                  "aktarilamadi. Onceki kararlari bilmiyorsan uydurma; kullaniciya sor.)")
+
+
+KISA_MESAJI = ("AstraBridge: Sohbet ozeti cok kisa cikti (%d karakter, en az %d bekleniyordu) ve gecmisin yerine "
+               "konmadi; mesajlariniz sohbette duruyor. Tekrar deneyin ya da daha guclu bir model secin.")
+
+
+def en_az_karakter(girdi_bayt, ayar=None):
+    """Bu buyuklukteki bir konusmanin ozeti en az kac karakter olmali.
+    Yalniz bozuk/bos sayilacak kadar kisa ozeti yakalar; ozetin yeterliligini boyuttan cikarmaz.
+    Olcum (10 Ekim 2026, 646.955 baytlik gunluk + bes olgu): guclu modelin dogru ozeti 1500-1700
+    karakterdi; boyuta oranli yuksek esik (2587) bu dogru ozeti reddedip sohbeti kilitledi.
+    Hafiza kaybinin asil onlemi ozeti guclu modele yazdirmaktir (bridge.py _ozet_openai)."""
+    ayar = ayar or {}
+    tavan = int(ayar.get("en_az_tavan", 300))
+    oran = max(1, int(ayar.get("en_az_oran", 2000)))     # her 2000 bayt girdi icin 1 karakter
+    return max(0, min(tavan, int(girdi_bayt) // oran))
+
+
+def tetik_mi(req):
+    """Istek bir sikistirma istegi mi (girdinin son ogesi compaction_trigger)?"""
+    ogeler = req.get("input")
+    return (isinstance(ogeler, list) and bool(ogeler) and isinstance(ogeler[-1], dict)
+            and ogeler[-1].get("type") == "compaction_trigger")
+
+
+def ozet_ogesi(metin, kimlik_tohumu=""):
+    """Duz metin ozeti Codex'in bekledigi compaction ogesine sarar."""
+    kimlik = "cmp_astrabridge_" + hashlib.sha256((kimlik_tohumu + metin).encode("utf-8")).hexdigest()[:32]
+    return {"type": "compaction", "id": kimlik,
+            "encrypted_content": ISARET + base64.b64encode(metin.encode("utf-8")).decode("ascii")}
+
+
+def ozet_metni(oge):
+    """Koprunun urettigi compaction ogesinden duz metni cikarir; kopru ogesi degilse None."""
+    icerik = oge.get("encrypted_content") if isinstance(oge, dict) else None
+    if not isinstance(icerik, str) or not icerik.startswith(ISARET):
+        return None
+    try:
+        return base64.b64decode(icerik[len(ISARET):]).decode("utf-8")
+    except Exception:
+        return None
+
+
+def _ozet_mesaji(metin):
+    return {"type": "message", "role": "user",
+            "content": [{"type": "input_text", "text": OZET_BASLIK + "\n" + metin.strip() + "\n" + OZET_BITIS}]}
+
+
+def ozetleri_ac(req, yabanci_hedef=False, coz=None):
+    """Giden istekteki compaction ogelerini hedefin okuyabilecegi bicime getirir (yerinde).
+    - Koprunun urettigi ozet -> duz metin kullanici mesaji (her hedefte).
+    - Baska saglayicinin (OpenAI) sifreli ozeti: hedef OpenAI ise dokunulmaz; hedef yabanciysa (9Router) coz(oge)
+      ile duz metne cevrilir, olmazsa OKUNAMADI_NOTU konur.
+    Doner: {'acilan': n, 'cozulen': n, 'okunamayan': n}"""
+    bilgi = {"acilan": 0, "cozulen": 0, "okunamayan": 0}
+    ogeler = req.get("input")
+    if not isinstance(ogeler, list):
+        return bilgi
+    yeni = []
+    for oge in ogeler:
+        if isinstance(oge, dict) and oge.get("type") == "compaction":
+            metin = ozet_metni(oge)
+            if metin is not None:
+                yeni.append(_ozet_mesaji(metin)); bilgi["acilan"] += 1
+                continue
+            if yabanci_hedef:
+                cozulmus = None
+                if coz is not None:
+                    try:
+                        cozulmus = coz(oge)
+                    except Exception:
+                        cozulmus = None
+                if cozulmus:
+                    yeni.append(_ozet_mesaji(cozulmus)); bilgi["cozulen"] += 1
+                else:
+                    yeni.append({"type": "message", "role": "user",
+                                 "content": [{"type": "input_text", "text": OKUNAMADI_NOTU}]}); bilgi["okunamayan"] += 1
+                continue
+        yeni.append(oge)
+    if bilgi["acilan"] or bilgi["cozulen"] or bilgi["okunamayan"]:
+        req["input"] = yeni
+    return bilgi
+
+
+def ozet_istegi_hazirla(req, istem=None):
+    """Sikistirma istegini (sonunda compaction_trigger) duz metin ozet istegine cevirir (yerinde)."""
+    ogeler = [o for o in req.get("input") or [] if not (isinstance(o, dict) and o.get("type") == "compaction_trigger")]
+    ogeler.append({"type": "message", "role": "user", "content": [{"type": "input_text", "text": istem or OZET_ISTEMI}]})
+    req["input"] = ogeler
+    req["tool_choice"] = "none"
+    req["stream"] = True
+    return req
+
+
+def _olay(d):
+    return b"event: " + d["type"].encode() + b"\ndata: " + json.dumps(d, ensure_ascii=False).encode("utf-8") + b"\n\n"
+
+
+class OzetAkisi:
+    """Ozet isteginin SSE yanitini Codex'in bekledigi tek 'compaction' ogesine cevirir.
+    ic: once calisan cevirici (SseRewriter). Metin gelmezse compaction ogesi uretmez (Codex hatayi gosterir)."""
+
+    def __init__(self, ic=None, tohum="", en_az=0):
+        self.ic = ic
+        self.tohum = tohum
+        self.en_az = en_az       # bundan kisa ozet kabul edilmez (bkz. en_az_karakter)
+        self.kisa = False
+        self.buf = b""
+        self.parcalar = {}       # item_id -> delta metni
+        self.bitenler = []       # tamamlanan mesaj metinleri
+        self.metin = None        # sonuc (gunluk/test icin)
+        self.bitti = False
+
+    def _topla(self):
+        metin = "\n\n".join(t for t in self.bitenler if t.strip())
+        if not metin.strip():
+            metin = "\n\n".join(t for t in self.parcalar.values() if t.strip())
+        return metin.strip()
+
+    def _blok(self, blok):
+        veri = [s[5:].strip() for s in re.split(rb"\r?\n", blok) if s.startswith(b"data:")]
+        if not veri:
+            return b""
+        try:
+            d = json.loads(b"\n".join(veri))
+        except Exception:
+            return b""
+        if not isinstance(d, dict):
+            return b""
+        t = d.get("type", "")
+        if t == "response.created":
+            return _olay(d)
+        if t == "response.output_text.delta":
+            self.parcalar[d.get("item_id")] = self.parcalar.get(d.get("item_id"), "") + (d.get("delta") or "")
+            return b": ozet\n\n"                      # baglantiyi canli tutar; Codex yorum satirini yok sayar
+        if t == "response.output_item.done":
+            oge = d.get("item") or {}
+            if oge.get("type") == "message":
+                self.bitenler.append("".join(p.get("text", "") for p in oge.get("content") or []
+                                             if isinstance(p, dict) and p.get("type") == "output_text"))
+            return b": ozet\n\n"
+        if t == "response.completed":
+            self.metin = self._topla()
+            self.bitti = True
+            if not self.metin:
+                return _olay(d)                       # ozet yok: Codex "0 compaction ogesi" hatasini gosterir
+            if len(self.metin) < self.en_az:
+                # Anormal kisa ozet gecmisin yerine konmaz: Codex hatayi gosterir, sohbet oldugu gibi kalir.
+                self.kisa = True
+                yanit = dict(d.get("response") or {})
+                yanit["status"] = "failed"; yanit["output"] = []
+                yanit["error"] = {"code": "astrabridge_ozet_kisa", "message": KISA_MESAJI % (len(self.metin), self.en_az)}
+                return _olay({"type": "response.failed", "response": yanit})
+            oge = ozet_ogesi(self.metin, self.tohum)
+            yanit = dict(d.get("response") or {})
+            yanit["output"] = [oge]
+            return (_olay({"type": "response.output_item.done", "output_index": 0, "item": oge})
+                    + _olay({"type": "response.completed", "response": yanit}))
+        if t in ("response.failed", "response.incomplete", "error"):
+            return _olay(d)
+        return b""
+
+    def sonuc_notu(self):
+        """Gunluk satiri icin sonuc (icerik yazilmaz)."""
+        if not self.metin:
+            return "ozet URETILEMEDI"
+        if self.kisa:
+            return f"ozet REDDEDILDI: {len(self.metin)} karakter, en az {self.en_az} bekleniyordu; gecmis korunuyor"
+        return f"ozet uretildi, {len(self.metin)} karakter"
+
+    def feed(self, chunk):
+        if self.ic:
+            chunk = self.ic.feed(chunk)
+        self.buf += chunk
+        out = b""
+        while True:
+            m = re.search(rb"\r?\n\r?\n", self.buf)
+            if not m:
+                break
+            blok, self.buf = self.buf[:m.start()], self.buf[m.end():]
+            out += self._blok(blok)
+        return out
+
+    def flush(self):
+        if self.ic:
+            self.buf += self.ic.flush()
+        self.buf = b""
+        return b""
+
+
+# ---- OpenAI'nin sifreli ozetini duz metne cevirme (onbellekli) ----
+def onbellek_yolu(klasor, oge):
+    kimlik = str(oge.get("id") or hashlib.sha256(str(oge.get("encrypted_content")).encode()).hexdigest()[:32])
+    return os.path.join(klasor, re.sub(r"[^A-Za-z0-9_.-]", "_", kimlik)[:80] + ".txt")
+
+
+def onbellekten(klasor, oge):
+    try:
+        with open(onbellek_yolu(klasor, oge), encoding="utf-8") as f:
+            return f.read().strip() or None
+    except OSError:
+        return None
+
+
+def onbellege(klasor, oge, metin):
+    os.makedirs(klasor, exist_ok=True)
+    yol = onbellek_yolu(klasor, oge)
+    with open(yol + ".tmp", "w", encoding="utf-8") as f:
+        f.write(metin)
+    os.replace(yol + ".tmp", yol)
+
+
+def coz_istegi(oge, model, talimat="Sen bir konusma ozeti aktaricisisin."):
+    """Sifreli ozeti duz metne dokturmek icin OpenAI'ye gidecek istek govdesi."""
+    temiz = {k: v for k, v in oge.items() if k in ("type", "id", "encrypted_content")}
+    return {"model": model, "instructions": talimat, "store": False, "stream": True, "tools": [],
+            "tool_choice": "none", "parallel_tool_calls": False,
+            "reasoning": {"effort": "low", "context": "all_turns"},     # chatgpt.com arka ucu bunu sart kosuyor
+            "include": ["reasoning.encrypted_content"],
+            "input": [temiz, {"type": "message", "role": "user", "content": [{"type": "input_text", "text": COZ_ISTEMI}]}]}
+
+
+def sse_metni(govde):
+    """SSE govdesinden (bayt) asistan metnini toplar."""
+    a = OzetAkisi()
+    a.feed(govde if govde.endswith(b"\n\n") else govde + b"\n\n")
+    return a.metin if a.bitti else a._topla()
+
+
+# ---- Dongu freni ----
+# Ozetten sonra da baglam hedefin esigini asiyorsa (Codex son kullanici mesajlarini aynen tuttugu icin olabilir) Codex
+# ayni turda tekrar tekrar sikistirma ister; her biri basarili oldugu icin dongu kendiliginden bitmez (olcum: sik6).
+DONGU_MESAJI = ("AstraBridge: Bu sohbetin baglami, ozetlendikten sonra da secili modelin sinirina sigmiyor "
+                "(kisa surede %d ozet denendi). Dongu durduruldu. Daha buyuk baglam pencereli bir model secin ya da "
+                "yeni sohbet acin; mesajlariniz sohbette duruyor.")
+
+
+class DonguFreni:
+    """Ozet dongusunu durdurur, mesru sik sikistirmayi durdurmaz (10 Ekim 2026: kucuk esikli sohbette
+    10 dakikadaki 4. ozet reddedilip tur dusuyordu). Iki ayri sinir:
+    - art_arda: arada normal (ozet olmayan) istek gecmeden ust uste gelen ozet sayisi; gercek dongu budur.
+    - sinir: pencere_sn icindeki toplam ozet sayisi; her ozetin arasina normal istek giren yavas donguyu keser."""
+
+    def __init__(self, sinir=8, pencere_sn=600, art_arda=3):
+        self.sinir = sinir
+        self.pencere = pencere_sn
+        self.art_arda = art_arda
+        self.kayit = {}
+        self.ust_uste = {}
+
+    def normal(self, anahtar):
+        """Bu sohbette ozet olmayan bir istek gecti: art arda sayaci sifirlanir."""
+        self.ust_uste.pop(anahtar, None)
+
+    def izin(self, anahtar, simdi):
+        """Bu ozet istegine izin var mi? Varsa kaydeder."""
+        zamanlar = [t for t in self.kayit.get(anahtar, []) if simdi - t < self.pencere]
+        if len(zamanlar) >= self.sinir or self.ust_uste.get(anahtar, 0) >= self.art_arda:
+            self.kayit[anahtar] = zamanlar
+            return False
+        zamanlar.append(simdi)
+        self.kayit[anahtar] = zamanlar
+        self.ust_uste[anahtar] = self.ust_uste.get(anahtar, 0) + 1
+        if len(self.kayit) > 500:                      # bellek sismesin
+            for k in sorted(self.kayit, key=lambda k: self.kayit[k][-1])[:250]:
+                self.kayit.pop(k, None)
+                self.ust_uste.pop(k, None)
+        return True

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

@@ -0,0 +1,292 @@
+"""Eklenen modellerin gercek baglam penceresi ve yetenekleri (10 Ekim 2026).
+
+Neden: gecit model basina pencere vermiyor; kopru her modele abonelik kalibinin penceresini (272000)
+kopyaliyordu. Codex, kucuk pencereli modele geciste sohbeti kendisi sikistirir, ama bunu ilan edilen
+pencereye gore yapar (core/src/session/turn.rs maybe_run_previous_model_inline_compact). Pencere dogru
+ilan edilince o yol kendiliginden calisir; yanlis ilan edilince istek hedefe sigmaz.
+
+Kaynak sirasi (kucukten guvenilire degil, guvenilirden yedege):
+1. Hedefin kendi hatasindan ogrenilen sinir (ogren / ogrenilen): en guvenilir, diske yazilir.
+2. NanoGPT'nin acik model listesi (nano/... modelleri icin istegi tasiyan saglayicinin kendi degeri).
+3. Saglayici kisaltmasina gore yerel tablo (cc, cx, ag).
+4. Bilinmeyen: VARSAYILAN (temkinli) ve bir kez gunluk satiri.
+Combo: yapraklarinin en kucugu (yedege dusulurse de sigsin).
+Ust sinir TAVAN: ozeti abonelik modeli yazdigi icin gecmis onun penceresini asmamali.
+"""
+import json
+import os
+import re
+import time
+import urllib.request
+
+TAVAN = 272_000            # abonelik modellerinin penceresi; ozetleyen model bundan fazlasini okuyamaz
+VARSAYILAN = 128_000       # hakkinda hicbir sey bilinmeyen model
+TABAN = 8_000              # saglayici verisi bozuksa (0, eksi) kullanilmaz
+NANO_URL = "https://nano-gpt.com/api/v1/models?detailed=true"
+NANO_OMUR_SN = 24 * 3600
+NANO_DOSYA = "pencere-nano.json"
+OGRENILEN_DOSYA = "pencere-ogrenilen.json"
+ARACSIZ_DOSYA = "aracsiz-modeller.json"
+# Saglayici kisaltmasi -> (pencere, gorsel girdi, arac cagrisi). cc = Claude Code aboneligi, cx = Codex
+# aboneligi, ag = Antigravity. Degerler abonelik yollarinin temkinli sinirlaridir.
+_YEREL = (
+    (re.compile(r"^cx/"), (272_000, True, True)),
+    (re.compile(r"^cc/"), (200_000, True, True)),
+    (re.compile(r"^ag/claude"), (200_000, True, True)),
+    (re.compile(r"^ag/gemini"), (1_000_000, True, True)),
+    (re.compile(r"^ag/gpt-oss"), (131_072, False, True)),
+)
+# "maximum context length is 131072 tokens", "prompt is too long: 3040251 tokens > 1000000 maximum",
+# "context window of 32768 tokens", "exceeds the limit of 65536" ...
+_SINIR = (
+    re.compile(r"maximum context length (?:is|of) (\d{4,8})", re.I),
+    re.compile(r"\d{4,9} tokens? > (\d{4,8}) maximum", re.I),
+    re.compile(r"context (?:window|length|size)(?: limit)? (?:is|of) (\d{4,8})", re.I),
+    re.compile(r"(?:limit|maximum) of (\d{4,8}) tokens", re.I),
+    re.compile(r"max(?:imum)? context tokens\D{0,6}(\d{4,8})", re.I),
+)
+_TASMA = re.compile(r"context[_ ](?:length|window)[_ ]exceeded|maximum context length|prompt is too long|"
+                    r"context window|too many tokens|input is too long|exceeds? the (?:maximum |model.s )?context|max(?:imum)? context tokens", re.I)
+
+
+def _oku(yol):
+    try:
+        with open(yol, encoding="utf-8") as f:
+            v = json.load(f)
+        return v if isinstance(v, dict) else {}
+    except (OSError, ValueError):
+        return {}
+
+
+def _yaz(yol, veri):
+    gecici = yol + ".tmp"
+    with open(gecici, "w", encoding="utf-8") as f:
+        json.dump(veri, f, ensure_ascii=False)
+    os.replace(gecici, yol)
+
+
+def nano_sadelestir(ham):
+    """NanoGPT yaniti -> {model kimligi (kucuk harf): {"pencere", "gorsel", "arac"}}."""
+    cikti = {}
+    for m in (ham or {}).get("data") or []:
+        kimlik = str(m.get("id") or "").lower()
+        pencere = m.get("context_length")
+        if not kimlik or not isinstance(pencere, int) or pencere < TABAN:
+            continue
+        yetenek = m.get("capabilities") or {}
+        cikti[kimlik] = {"pencere": pencere, "gorsel": bool(yetenek.get("vision")),
+                         "arac": bool(yetenek.get("tool_calling"))}
+    return cikti
+
+
+def nano_yukle(home, ua="AstraBridge/1.0 (codex)", timeout=20, simdi=None, getir=None, ag=True):
+    """Onbellek tazeyse onu, degilse agdan yenisini dondurur. Ag hatasinda eski onbellek (yasina bakilmadan)
+    kullanilir; o da yoksa bos sozluk doner ve cagiran yerel tabloya duser. Hicbir durumda istisna atmaz.
+    ag=False: aga cikilmaz, eldeki onbellek doner (koprunun acilisi beklemesin diye)."""
+    simdi = time.time() if simdi is None else simdi
+    yol = os.path.join(home, NANO_DOSYA) if home else ""
+    onbellek = _oku(yol) if yol else {}
+    if onbellek.get("modeller") and simdi - float(onbellek.get("zaman") or 0) < NANO_OMUR_SN:
+        return onbellek["modeller"]
+    if not ag:
+        return onbellek.get("modeller") or {}
+    try:
+        if getir is None:
+            istek = urllib.request.Request(NANO_URL, headers={"User-Agent": ua, "Accept": "application/json"})
+            with urllib.request.urlopen(istek, timeout=timeout) as resp:
+                ham = json.load(resp)
+        else:
+            ham = getir()
+        modeller = nano_sadelestir(ham)
+        if modeller:
+            if yol:
+                try:
+                    _yaz(yol, {"zaman": simdi, "modeller": modeller})
+                except OSError:
+                    pass
+            return modeller
+    except Exception:  # noqa: BLE001 - ag, JSON, sertifika: hepsi "yerel tabloya dus" demek
+        pass
+    return onbellek.get("modeller") or {}
+
+
+def ogrenilen(home):
+    return {k: int(v) for k, v in _oku(os.path.join(home, OGRENILEN_DOSYA)).items()
+            if isinstance(v, (int, float)) and v >= TABAN} if home else {}
+
+
+def aracsizlar(home):
+    """Hedefin "arac cagrisi desteklenmiyor" dedigi modeller (kimlik kumesi)."""
+    return {k for k, v in _oku(os.path.join(home, ARACSIZ_DOSYA)).items() if v} if home else set()
+
+
+def aracsiz_mi(metin):
+    return bool(re.search(r"does not support tool|tool_choice_unsupported|tools? (?:are|is) not supported|"
+                          r"function calling is not supported", metin or "", re.I))
+
+
+def ogren_aracsiz(home, kimlik):
+    """True: kayit yeni eklendi."""
+    if not home or not kimlik:
+        return False
+    yol = os.path.join(home, ARACSIZ_DOSYA)
+    veri = _oku(yol)
+    if veri.get(kimlik):
+        return False
+    veri[kimlik] = True
+    try:
+        _yaz(yol, veri)
+    except OSError:
+        return False
+    return True
+
+
+def tasma_mi(metin):
+    return bool(_TASMA.search(metin or ""))
+
+
+def sinir_oku(metin):
+    """Hedefin tasma hatasindaki gercek sinir; yoksa None."""
+    for kalip in _SINIR:
+        m = kalip.search(metin or "")
+        if m and int(m.group(1)) >= TABAN:
+            return int(m.group(1))
+    return None
+
+
+def ogren(home, kimlik, sinir):
+    """Hedefin bildirdigi siniri kaydeder (yalniz kucultur). True: kayit degisti."""
+    if not home or not kimlik or not sinir or sinir < TABAN:
+        return False
+    yol = os.path.join(home, OGRENILEN_DOSYA)
+    veri = _oku(yol)
+    if isinstance(veri.get(kimlik), (int, float)) and veri[kimlik] <= sinir:
+        return False
+    veri[kimlik] = int(sinir)
+    try:
+        _yaz(yol, veri)
+    except OSError:
+        return False
+    return True
+
+
+def yol_bilgisi(yol, nano):
+    """"nano/z-ai/glm-5.3" ya da "cc/claude-opus-5-5" -> {"pencere","gorsel","arac","kaynak"} ya da None."""
+    yol = (yol or "").strip()
+    if yol.startswith("9router/"):
+        yol = yol[len("9router/"):]
+    if yol.startswith("nano/"):
+        n = (nano or {}).get(yol[len("nano/"):].lower())
+        if n:
+            return {**n, "kaynak": "nanogpt"}
+        return None
+    for kalip, (pencere, gorsel, arac) in _YEREL:
+        if kalip.match(yol):
+            return {"pencere": pencere, "gorsel": gorsel, "arac": arac, "kaynak": "yerel"}
+    return None
+
+
+def _yapraklar(dugum, derinlik=0):
+    if not isinstance(dugum, dict) or derinlik > 6:
+        return []
+    if dugum.get("kind") != "combo":
+        return [dugum.get("model")] if dugum.get("model") else []
+    cikti = []
+    for uye in dugum.get("members") or []:
+        cikti.extend(_yapraklar(uye, derinlik + 1))
+    return cikti
+
+
+def coz(kimlik, tur, yol, kayit=None, nano=None, ogr=None, aracsiz=()):
+    """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"}."""
+    bilinmeyen = {"pencere": VARSAYILAN, "gorsel": False, "arac": True, "kaynak": "varsayilan"}
+    if tur == "combo":
+        yapraklar = _yapraklar((kayit or {}).get("topology"))
+        bilgiler = [yol_bilgisi(y, nano) or dict(bilinmeyen) for y in yapraklar]
+        if not bilgiler:
+            sonuc = dict(bilinmeyen)
+        else:
+            sonuc = {"pencere": min(b["pencere"] for b in bilgiler),
+                     # Bir takim uyesi resmi goremese de digerleri gorur; sirali yedekte ilk uye belirler.
+                     "gorsel": bool(bilgiler[0]["gorsel"]), "arac": bool(bilgiler[0]["arac"]),
+                     "kaynak": "uyeler:" + ",".join(sorted({b["kaynak"] for b in bilgiler}))}
+    else:
+        if (yol or "").startswith("no-think/"):
+            # Dusunmesiz kopya: asil saglayici kimlikten okunur ("no-think-9router-cc-claude-..." -> cc).
+            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)
+    if kimlik in aracsiz:
+        sonuc = {**sonuc, "arac": False}
+    sinir = (ogr or {}).get(kimlik)
+    if sinir and sinir < sonuc["pencere"]:
+        sonuc = {**sonuc, "pencere": int(sinir), "kaynak": "ogrenilen"}
+    sonuc["pencere"] = max(TABAN, min(TAVAN, int(sonuc["pencere"])))
+    return sonuc
+
+
+def kisa(pencere):
+    """8192 -> "8K", 131072 -> "128K", 272000 -> "272K"."""
+    return f"{round(pencere / 1024) if pencere < 262_144 and pencere % 1024 == 0 else round(pencere / 1000)}K"
+
+
+# ---- Istek oncesi tasma bekcisi ----
+# Codex sikistirmadan sonra kullanici mesajlarini AYNEN tutar; cok buyuk bir yapistirma (ya da dev arac
+# ciktisi) kucuk pencereli hedefe yine sigmaz ve hedef bos akisla doner (10 Ekim 2026 olcumu: 390 KB istek,
+# 64K pencere, Codex 5 kez yeniden deneyip "stream closed" ile dustu). Bekci, hedefe giden KOPYADA en buyuk
+# eski metin parcalarinin ortasini cikarir; yine sigmazsa istegi gondermeden anlasilir hata doner.
+BAYT_BOLU_TOKEN = 3.2        # olcum (10 Ekim 2026): 540 KB duz Turkce metin = 171016 token (3,16 bayt/token)
+DOLULUK = 0.97               # pencerenin bu oranini asan istek kirpilir / gonderilmez
+KIRP_ESIK = 6000             # bundan kisa metin parcasi kirpilmaz
+KIRP_BAS = KIRP_SON = 1500
+
+
+def tahmini_token(req):
+    return int(len(json.dumps(req, ensure_ascii=False).encode("utf-8")) / BAYT_BOLU_TOKEN)
+
+
+def _metin_parcalari(req):
+    """Kirpilabilir (sahip, anahtar) ciftleri: arac ciktilari ile eski kullanici/asistan mesajlari.
+    Son kullanici mesajina ve talimat tasiyan developer/system mesajlarina (Codex kurallari, skill
+    yonergeleri, kanca baglami) dokunulmaz."""
+    girdi = req.get("input")
+    if not isinstance(girdi, list):
+        return []
+    son_kullanici = max((i for i, it in enumerate(girdi) if isinstance(it, dict) and it.get("role") == "user"
+                         and it.get("type", "message") == "message"), default=-1)
+    parcalar = []
+    for i, it in enumerate(girdi):
+        if not isinstance(it, dict) or i == son_kullanici or it.get("role") in ("developer", "system"):
+            continue
+        for alan in ("content", "output"):
+            deger = it.get(alan)
+            if isinstance(deger, str):
+                parcalar.append((it, alan))
+            elif isinstance(deger, list):
+                for p in deger:
+                    if isinstance(p, dict) and isinstance(p.get("text"), str):
+                        parcalar.append((p, "text"))
+    return parcalar
+
+
+def sigdir(req, pencere_token):
+    """Istegi hedef pencereye sigdirir. Donus: (kirpilan parca sayisi, sigdi mi, tahmini token)."""
+    sinir = int(pencere_token * DOLULUK)
+    tahmin = tahmini_token(req)
+    if not pencere_token or tahmin <= sinir:
+        return 0, True, tahmin
+    kirpilan = 0
+    parcalar = sorted(_metin_parcalari(req), key=lambda sa: len(sa[0][sa[1]]), reverse=True)
+    for sahip, anahtar in parcalar:
+        metin = sahip[anahtar]
+        if len(metin) < KIRP_ESIK:
+            break
+        sahip[anahtar] = (metin[:KIRP_BAS] + f"\n[... {len(metin) - KIRP_BAS - KIRP_SON} karakter çıkarıldı (köprü): "
+                          f"seçili modelin bağlam penceresine sığmıyordu ...]\n" + metin[-KIRP_SON:])
+        kirpilan += 1
+        tahmin = tahmini_token(req)
+        if tahmin <= sinir:
+            return kirpilan, True, tahmin
+    return kirpilan, tahmin <= sinir, tahmin

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

@@ -0,0 +1,111 @@
+"""9Router'a giden isteklerde resim, video, ses, PDF ve dev içerikleri sadeleştirir (24 Eylül 2026, kullanıcı onayı).
+
+Sorun: Codex, image_gen aracının ürettiği resmi (≈3 MB base64 PNG) araç çıktısı olarak sohbete geri koyuyor.
+9Router'ın Claude çevirisi bunu düz yazı sayıyor: istek 3 milyon token'a çıktı ("prompt is too long:
+3040251 tokens > 1000000 maximum") ve sohbetteki sonraki HER tur 400 ile düştü; sohbet kurtarılamadı.
+Aynısı video, ses, PDF/dosya ve çok büyük araç çıktılarıyla da olabilir (kullanıcı isteği: "tekrar böyle sorun olmasın").
+
+Kural:
+- Medya parçaları (resim, dosya/PDF, ses, video): araç çıktılarında ve eski mesajlarda kısa notla değiştirilir.
+  Kullanıcının SON mesajındaki medya toplamı TUT_BAYT'ı aşmıyorsa korunur (yeni eklenen dosyayı model görebilsin).
+- Tür ne olursa olsun tek başına DEV_BAYT'tan büyük her parça (son mesajdaki korunanlar hariç) notla değiştirilir.
+- Düz yazı araç çıktısı DEV_BAYT'tan büyükse başı ve sonu kalır, ortası notla kısaltılır.
+Codex'in kendi kaydına dokunulmaz; yalnız 9Router'a giden kopya değişir.
+"""
+import json
+
+TUT_BAYT = 1_000_000
+DEV_BAYT = 1_000_000
+RESIM_TUT_BAYT = TUT_BAYT  # eski ad
+MEDYA_TURLERI = {'input_image': 'resim', 'image': 'resim', 'image_url': 'resim',
+                 'input_file': 'dosya/PDF', 'file': 'dosya/PDF',
+                 'input_audio': 'ses', 'audio': 'ses',
+                 'input_video': 'video', 'video': 'video'}
+
+
+def _boyut(p):
+    try:
+        return len(json.dumps(p, ensure_ascii=False))
+    except (TypeError, ValueError):
+        return len(str(p))
+
+
+def _medya_mi(p):
+    return isinstance(p, dict) and p.get('type') in MEDYA_TURLERI
+
+
+def _not(p):
+    tur = MEDYA_TURLERI.get(p.get('type'), p.get('type') or 'içerik') if isinstance(p, dict) else 'içerik'
+    ad = p.get('filename') or p.get('file_path') or p.get('path') or '' if isinstance(p, dict) else ''
+    ek = f' ({ad})' if ad else ''
+    return {'type': 'input_text',
+            'text': f'[{tur}{ek} çıkarıldı (AstraBridge): bu yoldan gönderilemiyor, ~{_boyut(p) // 1024} KB; '
+                    'gerekirse dosyayı yolundan aç]'}
+
+
+def _kisalt(metin):
+    yarim = DEV_BAYT // 4
+    return (metin[:yarim] + f'\n[... {len(metin) - 2 * yarim} karakter çıkarıldı (AstraBridge): çıktı çok büyüktü ...]\n'
+            + metin[-yarim:])
+
+
+def resimleri_sadelestir(req, tut_bayt=TUT_BAYT, gorsel=False):
+    """(değiştirilen parça sayısı, kazanılan bayt). req['input'] yerinde değişir.
+    gorsel=True (hedef model resim görebiliyor): eski KULLANICI mesajlarındaki resimler de, en yeniden eskiye
+    toplam tut_bayt'ı aşmadıkça korunur (10 Ekim 2026: resim görebilen modele geçince "göremiyorum" diyordu).
+    Araç çıktılarındaki medya her durumda notla değiştirilir."""
+    inp = req.get('input')
+    if not isinstance(inp, list):
+        return 0, 0
+    son_kullanici = None
+    for i, it in enumerate(inp):
+        if isinstance(it, dict) and it.get('type') == 'message' and it.get('role') == 'user':
+            son_kullanici = i
+    koru = set()
+    if son_kullanici is not None:
+        icerik = inp[son_kullanici].get('content')
+        if isinstance(icerik, list):
+            medya = [p for p in icerik if _medya_mi(p)]
+            if medya and sum(_boyut(p) for p in medya) <= tut_bayt:
+                koru.add(son_kullanici)
+    if gorsel:
+        kalan = tut_bayt - sum(_boyut(p) for i in koru for p in inp[i].get('content') or [] if _medya_mi(p))
+        for i in range(len(inp) - 1, -1, -1):
+            it = inp[i]
+            if i in koru or not (isinstance(it, dict) and it.get('type') == 'message' and it.get('role') == 'user'):
+                continue
+            icerik = it.get('content')
+            resimler = [p for p in icerik if _medya_mi(p) and MEDYA_TURLERI.get(p.get('type')) == 'resim'] \
+                if isinstance(icerik, list) else []
+            diger = [p for p in icerik if _medya_mi(p) and p not in resimler] if isinstance(icerik, list) else []
+            boyut = sum(_boyut(p) for p in resimler)
+            if resimler and not diger and boyut <= kalan:
+                koru.add(i)
+                kalan -= boyut
+    sayi = kazanc = 0
+    for i, it in enumerate(inp):
+        if not isinstance(it, dict) or i in koru:
+            continue
+        for alan in ('content', 'output'):
+            deger = it.get(alan)
+            if isinstance(deger, str) and len(deger) > DEV_BAYT:
+                yeni = _kisalt(deger)
+                kazanc += len(deger) - len(yeni)
+                sayi += 1
+                it[alan] = yeni
+                continue
+            if not isinstance(deger, list):
+                continue
+            degisti = False
+            yeni_liste = []
+            for p in deger:
+                if _medya_mi(p) or _boyut(p) > DEV_BAYT:
+                    kazanc += _boyut(p)
+                    sayi += 1
+                    degisti = True
+                    yeni_liste.append(_not(p))
+                else:
+                    yeni_liste.append(p)
+            if degisti:
+                it[alan] = yeni_liste
+    return sayi, kazanc

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

@@ -0,0 +1,83 @@
+"""Regression coverage for Codex -> external API access_programs compatibility."""
+import ast
+import copy
+import json
+from pathlib import Path
+import unittest
+from unittest.mock import Mock
+import urllib.request
+
+
+# Load only the actual adapter and routing method: no catalog/network/thread
+# startup or credential loading is needed to exercise the production code.
+source = ast.parse(Path(__file__).with_name("bridge.py").read_text(encoding="utf-8"))
+flatten = next(n for n in source.body if isinstance(n, ast.FunctionDef) and n.name == "flatten_request")
+claude_sonu = next(n for n in source.body if isinstance(n, ast.FunctionDef) and n.name == "claude_sonu_duzelt")
+handler = next(n for n in source.body if isinstance(n, ast.ClassDef) and n.name == "H")
+responses = next(n for n in handler.body if isinstance(n, ast.FunctionDef) and n.name == "_responses")
+
+
+class AccessPrograms(unittest.TestCase):
+    def setUp(self):
+        self.upstream = Mock(return_value=Mock(status=200))
+        self.env = {
+            "json": json,
+            "urllib": Mock(request=Mock(Request=urllib.request.Request, urlopen=self.upstream)),
+            "decompress": lambda body, encoding: body,
+            "MODEL_MAP": {},
+            "CFG": {"nine_router_catalog": {"enabled": True, "route": "9router", "prefix": "9r/"},
+                    "resim_sadelestir": False, "pano_kanca_user": False},
+            "ROUTES": {"9router": {"url": "https://example.invalid/v1/responses", "key": "test-only", "flatten_tools": True}},
+            "fix_tool_ids": lambda req: 0,
+            "drop_foreign_items": lambda req: 0,
+            "SseRewriter": Mock(),
+            "log": lambda message: None, "pencere": __import__("pencere"), "IDE_BILGI": {}, "yarim": __import__("yarim"), "nokta_mesaji_mi": lambda req: False, "EXTRA_MODELS": [],
+            "DEBUG": False, "UA": "test", "RETRIES": 1, "UPSTREAM_IDLE_TIMEOUT": 3900,
+        }
+        exec(compile(ast.Module(body=[flatten, claude_sonu, responses], type_ignores=[]), "bridge.py", "exec"), self.env)
+
+    def request(self, model):
+        return {"model": model, "access_programs": {"cyber": "standard"},
+                "metadata": {"access_programs": "preserve nested data"},
+                "input": [{"role": "user", "content": [{"type": "input_text", "text": "hello"}]}],
+                "tools": [{"type": "function", "name": "echo", "parameters": {"type": "object", "properties": {}}}]}
+
+    def test_adapter_removes_only_top_level_field(self):
+        req = self.request("meta/muse-spark-1.3")
+        original = copy.deepcopy(req)
+        self.env["flatten_request"](req)
+        self.assertNotIn("access_programs", req)
+        self.assertEqual(req["metadata"], original["metadata"])
+        self.assertEqual(req["input"], original["input"])
+        self.assertEqual(req["tools"][0]["name"], "echo")
+
+    def test_absent_null_and_empty_values(self):
+        for value in (None, {}, {"cyber": "standard"}):
+            with self.subTest(value=value):
+                req = {"input": [], "access_programs": value}
+                self.env["flatten_request"](req)
+                self.assertNotIn("access_programs", req)
+        self.env["flatten_request"]({"input": []})
+
+    def test_model_and_combo_external_request_strips_field(self):
+        for model in ("9r/meta/muse-spark-1.3-contributor", "9r/Fusion-Hizli"):
+            with self.subTest(model=model):
+                body = json.dumps(self.request(model)).encode()
+                fake = Mock(headers={})
+                self.env["_responses"](fake, 1, "/responses", body)
+                sent = json.loads(self.upstream.call_args.args[0].data)
+                self.assertNotIn("access_programs", sent)
+                self.assertEqual(sent["model"], model.removeprefix("9r/"))
+                self.assertIn("access_programs", json.loads(body))
+                fake._stream.assert_called_once()
+
+    def test_chatgpt_passthrough_preserves_original_body(self):
+        body = json.dumps(self.request("gpt-6-astra")).encode()
+        fake = Mock(headers={})
+        self.env["_responses"](fake, 1, "/responses", body)
+        self.assertEqual(fake._passthrough.call_args.args[2], body)
+        self.upstream.assert_not_called()
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,45 @@
+"""claude_sonu_duzelt testleri (9Router Claude prefill 400)."""
+import ast
+import json
+from pathlib import Path
+import unittest
+
+tree = ast.parse(Path(__file__).with_name("bridge.py").read_text(encoding="utf-8"))
+env = {}
+exec(compile(ast.Module(body=[n for n in tree.body if isinstance(n, ast.FunctionDef) and n.name == "claude_sonu_duzelt"], type_ignores=[]), "bridge.py", "exec"), env)
+f = env["claude_sonu_duzelt"]
+
+
+def msg(role, text="x"):
+    return {"type": "message", "role": role, "content": [{"type": "input_text", "text": text}]}
+
+
+class ClaudeSonu(unittest.TestCase):
+    def test_asistanla_biten_duzelir(self):
+        req = {"input": [msg("user"), msg("assistant")]}
+        self.assertTrue(f(req)[0])
+        self.assertEqual(req["input"][-1]["role"], "user")
+
+    def test_asistan_sonra_developer_duzelir(self):
+        # Sesli tur kapaninca: ... assistant, developer (9Router developer'i dusurur -> asistanla biter)
+        req = {"input": [msg("user"), msg("assistant"), msg("developer")]}
+        self.assertTrue(f(req)[0])
+        self.assertEqual(req["input"][-1]["role"], "user")
+
+    def test_reasoning_ile_biten_duzelir(self):
+        req = {"input": [msg("user"), {"type": "reasoning", "id": "rs_1"}]}
+        self.assertTrue(f(req)[0])
+
+    def test_kullaniciyla_biten_degismez(self):
+        req = {"input": [msg("assistant"), msg("user"), msg("developer")]}
+        self.assertFalse(f(req)[0])
+        self.assertEqual(len(req["input"]), 3)
+
+    def test_arac_sonucuyla_biten_degismez(self):
+        req = {"input": [msg("user"), {"type": "custom_tool_call", "call_id": "c"}, {"type": "custom_tool_call_output", "call_id": "c"}]}
+        self.assertFalse(f(req)[0])
+
+
+if __name__ == "__main__":
+    unittest.main()
+

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

@@ -0,0 +1,96 @@
+"""A 9Router combo (Fusion-*) must not be sent twice once it may be running upstream.
+
+22 Sep 2026: after a Cloudflare 524 the bridge resent 9r/Fusion-Orta three times and the whole
+Fusion ran (and billed) again. Failures before the work starts may still be retried.
+"""
+import ast
+import io
+import json
+from pathlib import Path
+import types
+import unittest
+from unittest.mock import Mock
+import urllib.error
+import urllib.request
+
+source = ast.parse(Path(__file__).with_name("bridge.py").read_text(encoding="utf-8"))
+pick = lambda name: next(n for n in source.body if isinstance(n, ast.FunctionDef) and n.name == name)
+handler = next(n for n in source.body if isinstance(n, ast.ClassDef) and n.name == "H")
+responses = next(n for n in handler.body if isinstance(n, ast.FunctionDef) and n.name == "_responses")
+
+
+def http_error(code, body=b"{}"):
+    return urllib.error.HTTPError("https://example.invalid", code, "x", {}, io.BytesIO(body))
+
+
+class ComboNotResent(unittest.TestCase):
+    def setUp(self):
+        self.upstream = Mock()
+        self.env = {
+            "json": json, "re": __import__("re"), "os": __import__("os"),
+            "time": types.SimpleNamespace(sleep=lambda s: None),
+            "urllib": types.SimpleNamespace(
+                request=types.SimpleNamespace(Request=urllib.request.Request, urlopen=self.upstream),
+                error=urllib.error),
+            "decompress": lambda body, encoding: body,
+            "MODEL_MAP": {},
+            "CFG": {"nine_router_catalog": {"enabled": True, "route": "9router", "prefix": "9r/"},
+                    "resim_sadelestir": False, "pano_kanca_user": False},
+            "ROUTES": {"9router": {"url": "https://example.invalid/v1/responses", "key": "test-only", "flatten_tools": False}},
+            "fix_tool_ids": lambda req: 0, "drop_foreign_items": lambda req: 0,
+            "SseRewriter": Mock(), "log": lambda message: None,
+            "DEBUG": False, "UA": "test", "RETRIES": 6, "UPSTREAM_IDLE_TIMEOUT": 3600,
+            "NO_RETRY_PATTERNS": [], "pencere": __import__("pencere"), "IDE_BILGI": {}, "yarim": __import__("yarim"), "nokta_mesaji_mi": lambda req: False, "EXTRA_MODELS": [],
+        }
+        exec(compile(ast.Module(body=[pick("flatten_request"), pick("claude_sonu_duzelt"), pick("is_timeout"), responses],
+                                type_ignores=[]), "bridge.py", "exec"), self.env)
+
+    def send(self, model):
+        body = json.dumps({"model": model, "input": [{"role": "user", "content": [{"type": "input_text", "text": "8 vezir"}]}]}).encode()
+        fake = Mock(headers={})
+        self.env["_responses"](fake, 1, "/responses", body)
+        return fake
+
+    def test_combo_timeout_is_not_resent(self):
+        self.upstream.side_effect = urllib.error.URLError(TimeoutError("timed out"))
+        fake = self.send("9r/Fusion-Orta")
+        self.assertEqual(self.upstream.call_count, 1)
+        fake._stream.assert_not_called()
+
+    def test_combo_504_and_524_are_not_resent(self):
+        for code in (504, 524):
+            with self.subTest(code=code):
+                self.upstream.reset_mock()
+                self.upstream.side_effect = http_error(code)
+                self.send("9r/Fusion-Agir")
+                self.assertEqual(self.upstream.call_count, 1)
+
+    def test_combo_cut_mid_stream_is_not_resent(self):
+        self.upstream.side_effect = None
+        self.upstream.return_value = Mock(status=200)
+        fake = self.send("9r/Fusion-Orta")
+        fake._stream.side_effect = TimeoutError("read timed out")
+        self.upstream.reset_mock()
+        with self.assertRaises(TimeoutError):
+            self.send_with(fake, "9r/Fusion-Orta")
+        self.assertEqual(self.upstream.call_count, 1)
+
+    def send_with(self, fake, model):
+        body = json.dumps({"model": model, "input": [{"role": "user", "content": [{"type": "input_text", "text": "8 vezir"}]}]}).encode()
+        self.env["_responses"](fake, 1, "/responses", body)
+
+    def test_combo_failure_before_work_starts_is_retried(self):
+        self.upstream.side_effect = [http_error(503), urllib.error.URLError(ConnectionRefusedError("refused")), Mock(status=200)]
+        fake = self.send("9r/Fusion-Orta")
+        self.assertEqual(self.upstream.call_count, 3)
+        fake._stream.assert_called_once()
+
+    def test_single_model_timeout_is_still_retried(self):
+        self.upstream.side_effect = [urllib.error.URLError(TimeoutError("timed out")), Mock(status=200)]
+        fake = self.send("9r/cc/claude-opus-5-5")
+        self.assertEqual(self.upstream.call_count, 2)
+        fake._stream.assert_called_once()
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,107 @@
+import json, os, tempfile, unittest
+import ide_catalog as c
+
+
+def girdi(mid, ad, yetenek=("chat",), sira=0, kaynak="omniroute", kind="model"):
+    return {"id": mid, "turkservis": {"display_name": ad, "capabilities": list(yetenek), "order": sira, "source": kaynak, "kind": kind}}
+
+
+KATALOG = [
+    girdi("Ajan-Arac", "OmniRoute · Ajan-Arac", sira=5),
+    girdi("9router-cc-opus", "OmniRoute · cc/claude-opus-5-5", sira=2),
+    girdi("9router-nano-x", "OmniRoute · nano/x", sira=1),
+    girdi("gorsel", "OmniRoute · gpt-image-1", ("image",)),
+    girdi("9router-Takim-Agir", "OmniRoute · Takim-Agir", sira=9, kind="combo"),
+    girdi("9router-Takim-Agir-6e65dba5", "OmniRoute · Takim-Agir", sira=8, kind="combo"),
+    girdi("Ajan-Arac", "OmniRoute · Ajan-Arac (tekrar)"),
+]
+
+
+class Ayar(unittest.TestCase):
+    def test_dosya_yoksa_varsayilan_acik(self):
+        self.assertEqual(c.ayar_oku(os.path.join(tempfile.gettempdir(), "yok-boyle-dosya.json")), {"enabled": True, "kapsam": "ide"})
+
+    def test_kapatma_ve_bozuk_dosya(self):
+        with tempfile.TemporaryDirectory() as d:
+            yol = os.path.join(d, "a.json")
+            for icerik, beklenen in [('{"enabled": false}', {"enabled": False, "kapsam": "ide"}),
+                                     ('{"enabled": true, "kapsam": "hepsi"}', {"enabled": True, "kapsam": "hepsi"}),
+                                     ('{"enabled": "hayir", "kapsam": "x"}', {"enabled": True, "kapsam": "ide"}),
+                                     ('bozuk', {"enabled": True, "kapsam": "ide"})]:
+                open(yol, "w", encoding="utf-8").write(icerik)
+                self.assertEqual(c.ayar_oku(yol), beklenen, icerik)
+
+
+class Yapilandirma(unittest.TestCase):
+    def test_config_yaml_okuma(self):
+        with tempfile.TemporaryDirectory() as d:
+            open(os.path.join(d, "config.yaml"), "w", encoding="utf-8").write(
+                "model:\n  default: Ajan-Arac\n  provider: turkservis\nproviders:\n  baska:\n    models:\n      Yabanci: {}\n"
+                "  turkservis:\n    base_url: https://ornek.test/v1/\n    # yorum\n    models:\n      Hermes-Master: {}\n"
+                "      'cc/claude-opus-5-5': {}\n    timeout: 3\nmcp_servers:\n  x:\n    models:\n      Degil: {}\n")
+            open(os.path.join(d, ".env"), "w", encoding="utf-8").write("A=1\nHERMES_CUSTOM_TURKSERVIS_API_KEY='sahte-anahtar'\n")
+            self.assertEqual(c.ide_yapilandirma(d), ("https://ornek.test/v1", "Ajan-Arac", ["Hermes-Master", "cc/claude-opus-5-5"]))
+            self.assertEqual(c.anahtar_oku(d), "sahte-anahtar")
+
+    def test_dosyalar_yoksa(self):
+        with tempfile.TemporaryDirectory() as d:
+            self.assertEqual(c.ide_yapilandirma(d), (c.DEFAULT_BASE, "", []))
+            self.assertEqual(c.anahtar_oku(d), "")
+
+
+class Secim(unittest.TestCase):
+    def test_ide_kapsami(self):
+        s = c.sec(KATALOG, ["cc/claude-opus-5-5"], "ide")
+        # Uye katalogu yerel config'teki adlarla sinirlanmaz.
+        self.assertEqual([x["id"] for x in s], ["9router-nano-x", "9router-cc-opus", "Ajan-Arac"])
+
+    def test_9router_combolari_gosterilmez(self):
+        katalog = [girdi("9router-Takim-Agir-6e65dba5", "Takim-Agir", kaynak="9router", sira=1),
+                   girdi("9router-Takim-Agir", "Takim-Agir (2)", sira=2, kind="combo"),
+                   girdi("Takim-Agir", "Takim-Agir (3)", sira=3),
+                   girdi("Ajan-Arac", "Ajan-Arac", sira=4),
+                   girdi("9router-nano-x", "nano/x", kaynak="9router", sira=5)]
+        s = c.sec(katalog, ["nano/x"], "ide")
+        # 9Router combosu ve gecidin 9router saglayicisindaki kopyasi yok; OmniRoute'un kendi combosu
+        # sayacsiz adiyla kalir. Dogrudan 9Router tekilleri de eklenmez.
+        self.assertEqual([(x["id"], x["ad"]) for x in s],
+                         [("Takim-Agir", "Takim-Agir"), ("Ajan-Arac", "Ajan-Arac")])
+
+    def test_9router_modelleri_yalniz_omniroute_uzerinden_eklenir(self):
+        katalog = [girdi("9router-nano-x-aaaa1111", "nano/x", kaynak="9router", sira=1),
+                   girdi("9router-nano-x", "nano/x (2)", sira=2),
+                   girdi("9router-ocg-y-bbbb2222", "ocg/y", kaynak="9router", sira=3),
+                   girdi("vag-z", "vag/z", sira=4),
+                   girdi("9router-ses", "nano/ses", ("tts",), kaynak="9router", sira=5),
+                   girdi("9router-Takim-Agir-6e65dba5", "Takim-Agir", kaynak="9router", sira=6)]
+        s = c.sec(katalog, [], "ide")
+        # Yerel model tanimi gerekmez; iki kaynak yerine yalniz OmniRoute yolu gelir.
+        self.assertEqual([(x["id"], x["ad"]) for x in s],
+                         [("9router-nano-x", "nano/x"), ("vag-z", "vag/z")])
+
+    def test_gorunen_ad_yalniz_saglayici_ve_model(self):
+        for tam, beklenen in [("OmniRoute · ag/gemini-3.8-flash", "ag/gemini-3.8-flash"),
+                              ("nano/qwen/qwen3.8-27b-obliterated:thinking", "nano/qwen3.8-27b-obliterated:thinking"),
+                              ("9Router · Nous-Research/inclusionai/ling-3.1-flash", "Nous-Research/ling-3.1-flash"),
+                              ("cf/@cf/qwen/qwq-32b", "cf/qwq-32b"),
+                              ("9R · nano/qwen/qwen3.8-27b", "nano/qwen3.8-27b"), ("9R · ag/gemini", "ag/gemini"),
+                              ("OmniRoute · Ajan-Arac", "Ajan-Arac"), ("cc/claude-opus-5-5", "cc/claude-opus-5-5")]:
+            self.assertEqual(c.kisa_ad(tam), beklenen, tam)
+
+    def test_cakisan_adlar_ayirt_edilir(self):
+        adlar = c.adlandir([("a", "nano/z-ai/glm-5.3"), ("b", "nano/baska/glm-5.3"), ("d", "cc/opus"), ("e-12345678", "OmniRoute · Takim-Agir")],
+                           dolu={"takim-agir"})
+        self.assertEqual(adlar["a"], "nano/z-ai/glm-5.3")       # kisa adi cakisan: aradaki halka geri gelir
+        self.assertEqual(adlar["b"], "nano/baska/glm-5.3")
+        self.assertEqual(adlar["d"], "cc/opus")
+        self.assertEqual(adlar["e-12345678"], "Takim-Agir [12345678]")
+        self.assertEqual(len(set(adlar.values())), 4)
+
+    def test_hepsi_kapsami_yalniz_sohbet(self):
+        s = c.sec(KATALOG, [], "hepsi")
+        self.assertEqual(len(s), 3)      # iki 9Router combosu hicbir kapsamda gosterilmez
+        self.assertNotIn("gorsel", [x["id"] for x in s])
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,91 @@
+"""Bridge 7: tool-less models are learned, flat gateway errors are translated, instructions are never trimmed."""
+import ast
+import json
+import tempfile
+import unittest
+from pathlib import Path
+
+import pencere
+
+tree = ast.parse(Path(__file__).with_name("bridge.py").read_text(encoding="utf-8"))
+names = {"fix_tool_ids", "SseRewriter", "phase_damgala", "asistan_mesaji_mi", "nokta_mesaji_mi", "hazir_yaniti"}
+nodes = [n for n in tree.body if isinstance(n, (ast.FunctionDef, ast.ClassDef)) and n.name in names]
+for node in tree.body:
+    if isinstance(node, ast.Assign) and any(isinstance(t, ast.Name) and t.id in
+            {"ID_PREFIX", "FOREIGN_ID_MARK", "REFERENCE_TYPES", "INLINE_TYPES", "ARAC_OGELERI", "NOKTA_ISARETLERI"} for t in node.targets):
+        nodes.insert(0, node)
+env = {"json": json, "re": __import__("re"), "time": __import__("time"), "log": lambda message: None, "pencere": pencere}
+exec(compile(ast.Module(body=nodes, type_ignores=[]), "bridge.py", "exec"), env)
+
+
+def feed(event, **kw):
+    adapter = env["SseRewriter"](set(), **kw)
+    raw = b"data: " + json.dumps(event).encode() + b"\n\n"
+    return [json.loads(line[6:]) for line in (adapter.feed(raw) + adapter.flush()).decode().splitlines()
+            if line.startswith("data: ")]
+
+
+class Ek(unittest.TestCase):
+    def test_model_without_tool_calls_is_reported_and_remembered(self):
+        seen = []
+        flat = {"type": "error", "code": "bad_request", "status_code": 400, "message":
+                '[400]: {"error":{"message":"This model does not support tool calls.","code":"tool_choice_unsupported"}}'}
+        out = feed(flat, hedef="m", aracsiz=seen.append)
+        self.assertEqual(out[0]["type"], "response.failed")
+        self.assertIn("araç çağrısını desteklemiyor", out[0]["response"]["error"]["message"])
+        self.assertEqual(seen, ["m"])
+        home = tempfile.mkdtemp()
+        self.assertTrue(pencere.ogren_aracsiz(home, "m"))
+        self.assertFalse(pencere.ogren_aracsiz(home, "m"))
+        self.assertFalse(pencere.coz("m", "model", "cc/claude-opus-5-5", aracsiz=pencere.aracsizlar(home))["arac"])
+        self.assertTrue(pencere.coz("n", "model", "cc/claude-opus-5-5", aracsiz=pencere.aracsizlar(home))["arac"])
+
+    def test_flat_overflow_error_is_translated_and_learned(self):
+        seen = []
+        flat = {"type": "error", "code": "bad_request", "message":
+                "Your prompt exceeds the model's context length. Max context tokens: 65536."}
+        out = feed(flat, hedef="m", tasma=lambda hedef, metin: seen.append(pencere.sinir_oku(metin)))
+        self.assertEqual(out[0]["response"]["error"]["code"], "context_length_exceeded")
+        self.assertEqual(seen, [65536])
+        self.assertEqual(feed({"type": "error", "code": "server_error", "message": "upstream 503"})[0]["type"], "error")
+
+    def test_guard_never_trims_instruction_messages(self):
+        big = "KURAL " * 40000
+        req = {"input": [
+            {"type": "message", "role": "developer", "content": [{"type": "input_text", "text": big}]},
+            {"type": "message", "role": "user", "content": [{"type": "input_text", "text": "eski " * 40000}]},
+            {"type": "message", "role": "user", "content": [{"type": "input_text", "text": "soru"}]}]}
+        pencere.sigdir(req, 65536)
+        self.assertEqual(req["input"][0]["content"][0]["text"], big)
+        self.assertIn("çıkarıldı (köprü)", req["input"][1]["content"][0]["text"])
+
+
+class Nokta(unittest.TestCase):
+    def user(self, content):
+        return {"type": "message", "role": "user", "content": content}
+
+    def test_only_a_lone_dot_from_the_user_is_answered_locally(self):
+        is_dot = env["nokta_mesaji_mi"]
+        self.assertTrue(is_dot({"input": [self.user([{"type": "input_text", "text": " . "}])]}))
+        self.assertTrue(is_dot({"input": [self.user("x"), self.user(".")]}))
+        for other in ("..", "?", "Selam", "", "1."):
+            self.assertFalse(is_dot({"input": [self.user([{"type": "input_text", "text": other}])]}), other)
+        self.assertFalse(is_dot({"input": [self.user("."), {"type": "function_call_output", "call_id": "c", "output": "x"}]}))
+        self.assertFalse(is_dot({"input": [self.user([{"type": "input_text", "text": "."}, {"type": "input_image", "image_url": "x"}])]}))
+        self.assertFalse(is_dot({"input": [{"type": "message", "role": "assistant", "content": "."}]}))
+        self.assertFalse(is_dot({"input": []}))
+
+    def test_local_answer_is_a_complete_response_with_a_final_answer(self):
+        raw = env["hazir_yaniti"]("ide/x", "cc/opus-5-5 hazır.").decode()
+        events = [json.loads(line[6:]) for line in raw.splitlines() if line.startswith("data: ")]
+        self.assertEqual([e["type"] for e in events], ["response.created", "response.output_item.added",
+                         "response.output_text.delta", "response.output_item.done", "response.completed"])
+        done = events[-1]["response"]
+        self.assertEqual(done["status"], "completed")
+        self.assertEqual(done["output"][0]["phase"], "final_answer")
+        self.assertEqual(done["output"][0]["content"][0]["text"], "cc/opus-5-5 hazır.")
+        self.assertEqual(done["usage"]["total_tokens"], 0)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,141 @@
+"""The shipped IDE must use the same public OmniRoute catalog as every member."""
+import io
+import json
+import unittest
+from unittest.mock import patch
+import ide_catalog as c
+
+
+def row(mid, name, source="omniroute", capabilities=("chat",)):
+    return {"id": mid, "turkservis": {"display_name": name, "source": source,
+                                     "capabilities": list(capabilities)}}
+
+
+class MemberCatalog(unittest.TestCase):
+    def test_metadata_classifies_only_public_models(self):
+        public = [row("plain", "Plain"), row("team", "Team")]
+        metadata = [{"id": "plain", "kind": "model"}, {"id": "team", "kind": "combo"},
+                    {"id": "internal", "kind": "combo"}]
+        replies = [io.BytesIO(json.dumps({"data": public}).encode()),
+                   io.BytesIO(json.dumps({"models": metadata}).encode())]
+        with patch.object(c, "ayar_oku", return_value={"enabled": True, "kapsam": "ide"}), \
+             patch.object(c, "anahtar_oku", return_value="test-key"), \
+             patch.object(c, "ide_yapilandirma", return_value=("https://example.test/v1", "", [])), \
+             patch.object(c.urllib.request, "urlopen", side_effect=replies):
+            status, _, _, selected = c.yukle()
+        self.assertEqual(status, "tamam")
+        self.assertEqual({m["id"]: m["kind"] for m in selected}, {"plain": "model", "team": "combo"})
+
+    def test_empty_catalog_is_a_refresh_failure(self):
+        with patch.object(c, "ayar_oku", return_value={"enabled": True, "kapsam": "ide"}), \
+             patch.object(c, "anahtar_oku", return_value="test-key"), \
+             patch.object(c, "ide_yapilandirma", return_value=("https://example.test/v1", "", [])), \
+             patch.object(c.urllib.request, "urlopen", return_value=io.BytesIO(b'{"data": []}')):
+            with self.assertRaises(ValueError):
+                c.yukle()
+
+    def test_public_omniroute_models_do_not_need_private_local_configuration(self):
+        rows = [row("9router-nano-x", "9R · nano/x"), row("agnes-flat", "Agnes Flat"),
+                row("Ajan-Arac", "Ajan-Arac"), row("image", "image", capabilities=("image",))]
+        self.assertEqual({m["id"] for m in c.sec(rows, [])},
+                         {"9router-nano-x", "agnes-flat", "Ajan-Arac"})
+
+    def test_direct_route_is_never_added_beside_omniroute(self):
+        rows = [row("9router-nano-x-direct", "9R · nano/x", "9router"),
+                row("9router-nano-x", "9R · nano/x")]
+        self.assertEqual([m["id"] for m in c.sec(rows, ["nano/x"], "hepsi")], ["9router-nano-x"])
+
+    def test_model_order_uses_combo_metadata_and_preserves_every_model(self):
+        models = [{"slug": "gpt-z", "display_name": "GPT Z", "priority": 1},
+                  {"slug": "ide/bekci-kurnaz", "display_name": "kurnaz", "priority": 2},
+                  {"slug": "ide/Z-Team", "display_name": "Z-Team", "priority": 5},
+                  {"slug": "ide/9router-cc-opus", "display_name": "9R · cc/opus", "priority": 3},
+                  {"slug": "ide/A-Team", "display_name": "A-Team", "priority": 4}]
+        extras = [{"slug": m["slug"], "kind": "combo" if m["slug"].endswith("Team") else "model"}
+                  for m in models if m["slug"].startswith("ide/")]
+        c.sirala_codex(models, extras)
+        self.assertEqual([m["slug"] for m in models],
+                         ["gpt-z", "ide/A-Team", "ide/Z-Team", "ide/bekci-kurnaz", "ide/9router-cc-opus"])
+        self.assertEqual([m["priority"] for m in models], [1, 2, 3, 4, 5])
+
+    def test_subscription_models_keep_their_own_order_priority_and_name(self):
+        models = [{"slug": "ide/GPT-6-Astra", "display_name": "GPT-6-Astra", "priority": 3},
+                  {"slug": "gpt-6-astra", "display_name": "GPT-6-Astra", "priority": 2},
+                  {"slug": "ide/A-Team", "display_name": "A-Team", "priority": 0},
+                  {"slug": "gpt-6.1-sol", "display_name": "GPT-6.1-Sol", "priority": 1},
+                  {"slug": "codex-auto-review", "display_name": "Codex Auto Review", "priority": 43}]
+        models.append({"slug": "ide/GPT-6-1-Sol", "display_name": "GPT-6-1-Sol", "priority": 2})
+        extras = [{"slug": "ide/GPT-6-Astra", "kind": "combo"}, {"slug": "ide/A-Team", "kind": "combo"},
+                  {"slug": "ide/GPT-6-1-Sol", "kind": "combo"}]
+        originals = [dict(m) for m in models if not m["slug"].startswith("ide/")]
+        c.sirala_codex(models, extras)
+        self.assertEqual([m for m in models if not m["slug"].startswith("ide/")], originals)
+        self.assertEqual([m["slug"] for m in models],
+                         ["gpt-6-astra", "gpt-6.1-sol", "codex-auto-review", "ide/A-Team", "ide/GPT-6-1-Sol",
+                          "ide/GPT-6-Astra"])
+        self.assertEqual([m["priority"] for m in models[3:]], [44, 45, 46])
+        self.assertEqual([m["display_name"] for m in models[4:]], ["GPT-6-1-Sol (AITURK)", "GPT-6-Astra (AITURK)"])
+
+    def test_description_line_tells_what_the_entry_is_and_fits_a_phone_row(self):
+        yedek = {"kind": "combo", "model": "Yedek", "strategy": "priority", "members": [
+            {"kind": "model", "model": "nano/z-ai/glm-5.3-flash-uncensored"},
+            {"kind": "model", "model": "nano/abliteration-ai/abliterated-model-large-v2"}]}
+        takim = {"topology": {"kind": "combo", "strategy": "priority", "members": [
+            {"kind": "combo", "model": "Takim-Hizli", "strategy": "fusion", "members": [
+                {"kind": "model", "model": "ag/gemini-3.8-flash-high"}, {"kind": "model", "model": "cc/claude-sonnet-5-5"}]},
+            yedek]}}
+        self.assertEqual(c.aciklama("Takim-Hizli", "Takim-Hizli", "combo", takim), "Takım: gemini+sonnet")
+        sirali = {"topology": {"kind": "combo", "strategy": "priority", "members": [
+            {"kind": "model", "model": "cx/gpt-6-astra"}, {"kind": "model", "model": "cc/claude-opus-5-5"},
+            {"kind": "model", "model": "cc/claude-sonnet-5-5"}, {"kind": "model", "model": "ag/gemini-3.8-flash-high"}]}}
+        self.assertEqual(c.aciklama("Ajan-Arac", "Ajan-Arac", "combo", sirali), "Sıralı: astra>opus>sonnet +1")
+        # An unresolved first member stays visible instead of being hidden behind the fallback.
+        eksik = {"topology": {"kind": "combo", "strategy": "priority", "members": [{"kind": "combo", "model": None}, yedek]}}
+        self.assertEqual(c.aciklama("GPT-6-Sol", "GPT-6-Sol", "combo", eksik), "Sıralı: ?>glm>abliterated")
+        donen = {"topology": {"kind": "combo", "strategy": "round-robin", "members": [yedek, yedek, yedek]}}
+        self.assertEqual(c.aciklama("Takim-Sira", "Takim-Sira", "combo", donen), "Dönüşümlü: 3 üye")
+        self.assertEqual(c.aciklama("X", "X", "combo", None), "Takım")
+        self.assertEqual(c.aciklama("9router-cc-claude-opus-5-5", "9R · cc/claude-opus-5-5", "model"), "Tek model · Claude")
+        self.assertEqual(c.aciklama("9router-nano-qwen-qwen3.8-27b-uncensored-thinking",
+                                    "9R · nano/qwen3.8-27b-uncensored:thinking", "model"),
+                         "NanoGPT · sansürsüz · düşünen")
+        self.assertEqual(c.aciklama("bekci-kurnaz", "kurnaz", "model"), "Tek model · Bekçi")
+        # 9Router aliases: cc = Claude Code, cx = OpenAI Codex, ag = Antigravity.
+        self.assertEqual(c.aciklama("9router-cx-gpt-6-astra", "9R · cx/gpt-6-astra", "model"), "Tek model · Codex")
+        self.assertEqual(c.aciklama("9router-ag-gemini-3.8-flash-high", "9R · ag/gemini-3.8-flash-high", "model"), "Tek model · Antigravity")
+        uzun = {"topology": {"kind": "combo", "strategy": "priority", "members": [
+            {"kind": "model", "model": f"x/model{chr(97 + i) * 9}"} for i in range(8)]}}
+        self.assertLessEqual(len(c.aciklama("U", "U", "combo", uzun)), c.ACIKLAMA_SINIRI)
+        for ad in ("Takim-Hizli", "9R · cc/claude-opus-5-5"):
+            self.assertNotIn(ad, c.aciklama(ad, ad, "combo" if "Takim" in ad else "model", takim))
+
+    def test_picker_names_are_combo_name_or_short_provider_slash_model(self):
+        # User decision, 10 Oct 2026: no "9R" mark; combos by name; single models as provider/model.
+        rows = [("Takim-Hizli", "Takim-Hizli", "combo"),
+                ("9router-cc-claude-opus-5-5", "9R · cc/claude-opus-5-5", "model"),
+                ("9router-cc-claude-opus-4-8", "9R · cc/claude-opus-4-8", "model"),
+                ("9router-cx-gpt-6-astra", "9R · cx/gpt-6-astra", "model"),
+                ("9router-ag-gemini-3.8-flash-high", "9R · ag/gemini-3.8-flash-high", "model"),
+                ("9router-nano-z-ai-glm-5.3-flash-uncensored", "9R · nano/glm-5.3-flash-uncensored", "model"),
+                ("agnes-agnes-2.0-flash", "Agnes 2.0 Flash", "model"),
+                ("agnes-agnes-2.0-flash-high", "agnes-2.0-flash-high", "model"),
+                ("bekci-bekci", "bekci", "model"), ("bekci-kurnaz", "kurnaz", "model"),
+                ("hf-deepseek-ai-DeepSeek-V3", "hf/DeepSeek V3", "model"),
+                ("no-think-9router-cc-claude-opus-5-5", "no-think/claude-opus-5-5", "model"),
+                ("no-think-9router-ag-claude-opus-4-6-thinking", "no-think/claude-opus-4-6-thinking", "model")]
+        adlar = c.adlandir([(k, a) for k, a, _ in rows], turler={k: t for k, _, t in rows})
+        self.assertEqual([adlar[k] for k, _, _ in rows],
+                         ["Takim-Hizli", "cc/opus-5-5", "cc/opus-4-8", "cx/gpt-6-astra", "agy/gemini-3.8-flash-high",
+                          "nano/glm-5.3-flash-uncensored", "agnes/agnes-2.0-flash", "agnes/agnes-2.0-flash-high",
+                          "bekci/bekci", "bekci/kurnaz", "hf/DeepSeek-V3", "cc/opus-5-5 (no-think)",
+                          "agy/opus-4-6-thinking (no-think)"])
+        self.assertFalse([a for a in adlar.values() if "9R" in a])
+        # Added models sort after the combos by provider then model.
+        models = [{"slug": "ide/" + k, "display_name": adlar[k], "priority": 0} for k, _, _ in rows]
+        c.sirala_codex(models, [{"slug": "ide/" + k, "kind": t} for k, _, t in rows])
+        gorunen = [m["display_name"] for m in models]
+        self.assertEqual(gorunen[0], "Takim-Hizli")
+        self.assertEqual(gorunen[1:], sorted(gorunen[1:], key=lambda a: tuple(p.casefold() for p in a.partition("/")[::2])))
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,106 @@
+"""Bridge 8: "modeli X yap" is handled by the bridge; a per-chat route survives until the user picks another model."""
+import tempfile
+import unittest
+
+import model_gecis as g
+
+MODELS = [("gpt-6-sol", "GPT-6-Sol"), ("gpt-6-astra", "GPT-6-Astra"), ("gpt-6.1-sol", "GPT-6.1-Sol"),
+          ("ide/9router-ag-gemini-3.8-flash-low", "agy/gemini-3.8-flash-low"),
+          ("ide/9router-ag-gemini-3.8-flash-high", "agy/gemini-3.8-flash-high"),
+          ("ide/9router-cc-claude-opus-5-5", "cc/opus-5-5"), ("ide/9router-cc-claude-opus-5-5-nt", "cc/opus-5-5 (no-think)"),
+          ("ide/9router-nano-z-ai-glm-5.3-flash-uncensored", "nano/glm-5.3-flash-uncensored"),
+          ("ide/agnes-agnes-2.0-flash", "agnes/agnes-2.0-flash"), ("ide/agnes-agnes-2.5-flash", "agnes/agnes-2.5-flash")]
+
+
+def user(text):
+    return {"type": "message", "role": "user", "content": [{"type": "input_text", "text": text}]}
+
+
+def voice(text):
+    return user(f"<realtime_delegation>\n  <input>{text}</input>\n  <transcript_delta>user: x</transcript_delta>\n</realtime_delegation>")
+
+
+def pick(text):
+    command = g.komut_coz(text)
+    return g.eslestir(command["ad"], MODELS) if command and command["tur"] == "gec" else command
+
+
+class Komut(unittest.TestCase):
+    def test_spoken_names_resolve_to_one_model(self):
+        for text, slug in [("modeli gemini flash low yap", "ide/9router-ag-gemini-3.8-flash-low"),
+                           ("Modeli Gemini 3.8 Flash High'a geçir", "ide/9router-ag-gemini-3.8-flash-high"),
+                           ("modeli klod opus yap", "ide/9router-cc-claude-opus-5-5"),
+                           ("modeli opusa geç", "ide/9router-cc-claude-opus-5-5"),
+                           ("modeli gpt 6 astra yap", "gpt-6-astra"), ("model geç gpt 6.1 sol", "gpt-6.1-sol"),
+                           ("modeli glm flaş sansürsüz yap", "ide/9router-nano-z-ai-glm-5.3-flash-uncensored")]:
+            self.assertEqual((pick(text) or {}).get("slug"), slug, text)
+
+    def test_ambiguous_name_lists_candidates_and_changes_nothing(self):
+        self.assertEqual(pick("modeli agnes yap"), {"adaylar": ["agnes/agnes-2.0-flash", "agnes/agnes-2.5-flash"]})
+
+    def test_ordinary_sentences_are_not_commands(self):
+        for text in ("Masaüstünde kaç klasör var", "bu modeli kullanarak bir site yap", "yapay zeka modeli nedir",
+                     "modeli değiştir", "hangi modeli önerirsin bu iş için bana söyle bakalım lütfen",
+                     "model " + "çok uzun bir cümle " * 5 + "yap"):
+            self.assertFalse(pick(text) and "slug" in pick(text), text)
+        self.assertEqual(g.komut_coz("seçili model hangisi"), {"tur": "sor"})
+        self.assertEqual(g.komut_coz("bu chatte ana model kim"), {"tur": "sor"})
+
+    def test_voice_delegation_yields_only_the_spoken_input(self):
+        text, index, spoken = g.son_kullanici_metni({"input": [user("a"), voice("modeli opus yap")]})
+        self.assertEqual((text, index, spoken), ("modeli opus yap", 1, True))
+        self.assertEqual(g.son_kullanici_metni({"input": [user("<skill>x</skill>")]})[0], None)
+        self.assertEqual(g.son_kullanici_metni({"input": [{"type": "function_call_output", "output": "x"}]})[0], None)
+
+
+class TurOrtasi(unittest.TestCase):
+    def test_message_after_tool_items_is_mid_turn_and_after_final_answer_is_not(self):
+        final = {"type": "message", "role": "assistant", "phase": "final_answer", "content": "ok"}
+        call = {"type": "function_call", "call_id": "c", "name": "shell", "arguments": "{}"}
+        out = {"type": "function_call_output", "call_id": "c", "output": "x"}
+        self.assertFalse(g.tur_ortasi({"input": [user("a"), final, user(".")]}, 2))
+        self.assertTrue(g.tur_ortasi({"input": [user("a"), call, out, user(".")]}, 3))
+        self.assertTrue(g.tur_ortasi({"input": [user("a"), call, out, voice("bekliyorum"), user(".")]}, 4))
+        self.assertTrue(g.tur_ortasi({"input": [user("a"), {"type": "message", "role": "assistant", "phase": "commentary",
+                                                            "content": "bakıyorum"}, user(".")]}, 2))
+        self.assertFalse(g.tur_ortasi({"input": [user(".")]}, 0))
+
+    def test_handover_note_replaces_only_the_spoken_input(self):
+        req = {"input": [voice("modeli opus yap")]}
+        g.metni_degistir(req, 0, g.devir_notu("cc/opus-5-5", "GPT-6-Sol"))
+        text = req["input"][0]["content"][0]["text"]
+        self.assertIn("<transcript_delta>", text)
+        self.assertIn("cc/opus-5-5 olarak devam ediyorum", text)
+        self.assertNotIn("modeli opus yap</input>", text)
+
+
+class Gecmis(unittest.TestCase):
+    def test_handled_commands_in_history_become_notes_but_the_last_message_is_left_alone(self):
+        req = {"input": [user("modeli gemini flash low yap"), user("Masaüstünde kaç dosya var"),
+                         voice("modeli opus yap"), user("modeli gpt 6 astra yap")]}
+        self.assertEqual(g.gecmisi_temizle(req, MODELS), 2)
+        self.assertIn("agy/gemini-3.8-flash-low olarak değiştirdi", req["input"][0]["content"][0]["text"])
+        self.assertEqual(req["input"][1]["content"][0]["text"], "Masaüstünde kaç dosya var")
+        self.assertIn("<transcript_delta>", req["input"][2]["content"][0]["text"])
+        self.assertEqual(req["input"][3]["content"][0]["text"], "modeli gpt 6 astra yap")
+        self.assertEqual(g.gecmisi_temizle(req, MODELS), 0)
+
+
+class Yon(unittest.TestCase):
+    def test_route_lasts_until_the_user_picks_another_model_in_the_list(self):
+        with tempfile.TemporaryDirectory() as home:
+            y = g.Yonlendirme(home)
+            y.koy("chat", "gpt-6-sol", "ide/x", simdi=1000)
+            self.assertEqual(g.Yonlendirme(home).al("chat", "gpt-6-sol", simdi=1001), "ide/x")     # survives a restart
+            self.assertIsNone(y.al("other", "gpt-6-sol", simdi=1001))
+            self.assertIsNone(y.al("chat", "gpt-6-astra", simdi=1002))                             # user picked another
+            self.assertIsNone(y.al("chat", "gpt-6-sol", simdi=1003))                               # and it stays cleared
+            y.koy("chat", "gpt-6-sol", "ide/x", simdi=1000)
+            y.koy("chat", "gpt-6-sol", "gpt-6-sol", simdi=1001)                                    # back to the picked one
+            self.assertIsNone(y.al("chat", "gpt-6-sol", simdi=1002))
+            y.koy("old", "a", "b", simdi=1000)
+            self.assertIsNone(y.al("old", "a", simdi=1000 + g.OMUR_SN + 1))
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,90 @@
+"""Provider-switch history regression tests, without startup or network access."""
+import ast
+import copy
+import json
+from pathlib import Path
+import unittest
+
+
+tree = ast.parse(Path(__file__).with_name("bridge.py").read_text(encoding="utf-8"))
+names = {"flatten_request", "fix_tool_ids", "drop_foreign_items", "SseRewriter", "phase_damgala",
+         "asistan_mesaji_mi"}
+nodes = [n for n in tree.body if isinstance(n, (ast.FunctionDef, ast.ClassDef)) and n.name in names]
+env = {"json": json, "re": __import__("re"), "log": lambda message: None, "pencere": __import__("pencere")}
+for node in tree.body:
+    if isinstance(node, ast.Assign) and any(isinstance(t, ast.Name) and t.id in
+            {"ID_PREFIX", "FOREIGN_ID_MARK", "REFERENCE_TYPES", "INLINE_TYPES", "ARAC_OGELERI"} for t in node.targets):
+        nodes.insert(0, node)
+exec(compile(ast.Module(body=nodes, type_ignores=[]), "bridge.py", "exec"), env)
+
+
+class ModelSwitch(unittest.TestCase):
+    def test_external_to_chatgpt_preserves_messages_and_paired_tool_calls(self):
+        req = {"input": [
+            {"type": "reasoning", "id": "rs_native", "encrypted_content": "native-reasoning"},
+            {"type": "reasoning", "id": "rs_chatcmpl-foreign"},
+            {"type": "item_reference", "id": "chatcmpl-foreign"},
+            {"type": "message", "id": "msg_chatcmpl-foreign", "role": "assistant", "content": "remember-4827"},
+            {"type": "custom_tool_call", "id": "fc_chatcmpl-call", "call_id": "call_4827", "name": "probe", "input": "hello"},
+            {"type": "custom_tool_call_output", "id": "fc_chatcmpl-output", "call_id": "call_4827", "output": "result-4827"},
+        ]}
+        self.assertEqual(env["fix_tool_ids"](req), 2)
+        self.assertEqual(env["drop_foreign_items"](req), 2)
+        self.assertEqual(req["input"][0]["encrypted_content"], "native-reasoning")
+        self.assertEqual(req["input"][1]["content"], "remember-4827")
+        self.assertEqual(req["input"][2]["id"], "ctc_chatcmpl-call")
+        self.assertEqual(req["input"][3]["id"], "ctco_chatcmpl-output")
+        self.assertEqual(req["input"][2]["call_id"], req["input"][3]["call_id"])
+        self.assertEqual(req["input"][3]["output"], "result-4827")
+
+    def test_chatgpt_to_external_preserves_custom_tool_history(self):
+        original = {"access_programs": {"cyber": "standard"}, "input": [
+            {"type": "custom_tool_call", "id": "ctc_4827", "call_id": "call_4827", "name": "probe", "input": "remember-4827"},
+            {"type": "custom_tool_call_output", "id": "ctco_4827", "call_id": "call_4827", "output": "result-4827"},
+        ], "tools": [{"type": "namespace", "name": "functions", "tools": [{"type": "custom", "name": "probe"}]}]}
+        req = copy.deepcopy(original)
+        self.assertEqual(env["flatten_request"](req), {"probe"})
+        env["fix_tool_ids"](req)
+        self.assertEqual(json.loads(req["input"][0]["arguments"]), {"input": "remember-4827"})
+        self.assertEqual(req["input"][1]["output"], "result-4827")
+        self.assertEqual(req["input"][0]["call_id"], req["input"][1]["call_id"])
+        self.assertEqual(req["input"][0]["type"], "function_call")
+        self.assertEqual(req["input"][1]["type"], "function_call_output")
+        self.assertIn("access_programs", original)
+
+    def test_streamed_external_custom_tool_can_return_to_codex(self):
+        event = {"type": "response.output_item.done", "item": {
+            "type": "function_call", "id": "fc_chatcmpl-probe", "call_id": "call_4827",
+            "name": "probe", "arguments": json.dumps({"input": "remember-4827"})}}
+        raw = ("event: response.output_item.done\ndata: " + json.dumps(event) + "\n\n").encode()
+        adapter = env["SseRewriter"]({"probe"})
+        out = adapter.feed(raw[:25]) + adapter.feed(raw[25:]) + adapter.flush()
+        rewritten = json.loads(next(line[6:] for line in out.decode().splitlines() if line.startswith("data: ")))
+        self.assertEqual(rewritten["item"]["type"], "custom_tool_call")
+        self.assertEqual(rewritten["item"]["input"], "remember-4827")
+        self.assertEqual(rewritten["item"]["call_id"], "call_4827")
+        self.assertEqual(rewritten["item"]["id"], "ctc_chatcmpl-probe")
+
+    def test_custom_stream_ids_are_valid_before_history_is_saved(self):
+        # Real failure after disabling the bridge and returning to OpenAI:
+        # input[32].id fc_call_... was saved as a custom_tool_call by Codex.
+        item = {"type": "function_call", "id": "fc_call_3f427ecc539d4c779c1252077701216f",
+                "call_id": "call_original", "name": "probe",
+                "arguments": json.dumps({"input": "keep this exact tool input"})}
+        adapter = env["SseRewriter"]({"probe"})
+        converted = []
+        for kind in ("response.output_item.added", "response.output_item.done"):
+            converted.append(adapter._fix({"type": kind, "item": dict(item)})["item"])
+        final = adapter._fix({"type": "response.completed", "response": {"output": [dict(item)]}})
+        converted.append(final["response"]["output"][0])
+        for result in converted:
+            self.assertEqual(result["type"], "custom_tool_call")
+            self.assertEqual(result["id"], "ctc_call_3f427ecc539d4c779c1252077701216f")
+            self.assertEqual(result["call_id"], "call_original")
+            self.assertEqual(result["input"], "keep this exact tool input")
+        history = {"input": converted}
+        self.assertEqual(env["fix_tool_ids"](history), 0)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,185 @@
+"""ozet_kopru testleri: 9Router icin sikistirma bagdastiricisi ve saglayicilar arasi ozet aktarimi."""
+import json
+import os
+import tempfile
+import unittest
+
+import ozet_kopru as o
+
+
+def msg(rol, metin):
+    return {"type": "message", "role": rol, "content": [{"type": "input_text", "text": metin}]}
+
+
+def sse(*olaylar):
+    return b"".join(b"event: " + e["type"].encode() + b"\ndata: " + json.dumps(e, ensure_ascii=False).encode() + b"\n\n" for e in olaylar)
+
+
+def coz(veri):
+    return [json.loads(s[5:]) for blok in veri.split(b"\n\n") for s in blok.split(b"\n") if s.startswith(b"data:")]
+
+
+OPENAI_OZETI = {"type": "compaction", "id": "cmp_0123", "encrypted_content": "gAAAAABsahte", "internal_chat_message_metadata_passthrough": {"turn_id": "t"}}
+
+
+class Istek(unittest.TestCase):
+    def test_tetik_algilanir_ve_ozet_istegine_cevrilir(self):
+        req = {"model": "m", "tools": [{"type": "function", "name": "x"}], "input": [msg("user", "KARAR-1: 14 Kasim"), {"type": "compaction_trigger"}]}
+        self.assertTrue(o.tetik_mi(req))
+        self.assertFalse(o.tetik_mi({"input": [msg("user", "normal")]}))
+        self.assertFalse(o.tetik_mi({"input": []}))
+        o.ozet_istegi_hazirla(req)
+        self.assertNotIn("compaction_trigger", json.dumps(req))
+        self.assertEqual(req["input"][0]["content"][0]["text"], "KARAR-1: 14 Kasim")      # gecmis aynen kalir
+        self.assertEqual(req["input"][-1]["role"], "user")
+        istem = req["input"][-1]["content"][0]["text"]
+        for baslik in ("KARARLAR VE GEREKCELERI", "ACIK ISLER", "ONEMLI SONUCLAR", "KULLANICININ ISTEGI"):
+            self.assertIn(baslik, istem)
+        self.assertEqual(req["tool_choice"], "none")
+
+    def test_kopru_ozeti_her_hedefte_duz_metne_acilir(self):
+        oge = o.ozet_ogesi("KARAR-1: teslim 14 Kasim\nACIK-IS-1: fatura onayi")
+        self.assertTrue(oge["id"].startswith("cmp_astrabridge_"))
+        self.assertNotIn("KARAR-1", json.dumps(oge))                         # ogede duz metin gorunmez (base64)
+        for yabanci in (False, True):
+            req = {"input": [msg("user", "once"), dict(oge), msg("user", "soru")]}
+            b = o.ozetleri_ac(req, yabanci_hedef=yabanci)
+            self.assertEqual(b["acilan"], 1)
+            metin = req["input"][1]["content"][0]["text"]
+            self.assertEqual(req["input"][1]["role"], "user")
+            self.assertIn("KARAR-1: teslim 14 Kasim", metin)
+            self.assertTrue(metin.startswith(o.OZET_BASLIK))
+            self.assertNotIn('"compaction"', json.dumps(req))
+
+    def test_openai_ozeti_openai_hedefinde_dokunulmaz(self):
+        req = {"input": [dict(OPENAI_OZETI), msg("user", "soru")]}
+        once = json.dumps(req, sort_keys=True)
+        b = o.ozetleri_ac(req, yabanci_hedef=False)
+        self.assertEqual(json.dumps(req, sort_keys=True), once)
+        self.assertEqual(b, {"acilan": 0, "cozulen": 0, "okunamayan": 0})
+
+    def test_openai_ozeti_yabanci_hedefte_duz_metne_cevrilir_ya_da_not_dusulur(self):
+        req = {"input": [dict(OPENAI_OZETI), msg("user", "soru")]}
+        b = o.ozetleri_ac(req, yabanci_hedef=True, coz=lambda oge: "KARAR-2: saglayici degismeyecek")
+        self.assertEqual(b["cozulen"], 1)
+        self.assertIn("KARAR-2", req["input"][0]["content"][0]["text"])
+        for bozuk in (None, lambda oge: None, lambda oge: 1 / 0):
+            req = {"input": [dict(OPENAI_OZETI), msg("user", "soru")]}
+            b = o.ozetleri_ac(req, yabanci_hedef=True, coz=bozuk)
+            self.assertEqual(b["okunamayan"], 1)
+            self.assertEqual(req["input"][0]["content"][0]["text"], o.OKUNAMADI_NOTU)   # sessiz kayip yok
+            self.assertNotIn("gAAAAAB", json.dumps(req))
+
+    def test_coz_istegi_yalniz_gerekli_alanlari_tasir(self):
+        g = o.coz_istegi(OPENAI_OZETI, "gpt-6-luna")
+        self.assertEqual(g["input"][0], {"type": "compaction", "id": "cmp_0123", "encrypted_content": "gAAAAABsahte"})
+        self.assertEqual(g["model"], "gpt-6-luna")
+        self.assertFalse(g["store"])
+
+
+class Akis(unittest.TestCase):
+    def _mesaj(self, metin, kimlik="msg_1"):
+        return {"id": kimlik, "type": "message", "role": "assistant", "content": [{"type": "output_text", "text": metin}]}
+
+    def test_metin_tek_compaction_ogesine_sarilir(self):
+        ozet = "1. KULLANICININ ISTEGI: x\n2. KARARLAR: KARAR-1 14 Kasim"
+        ham = sse({"type": "response.created", "response": {"id": "r1"}},
+                  {"type": "response.output_item.added", "item": {"id": "msg_1", "type": "message"}},
+                  {"type": "response.output_text.delta", "item_id": "msg_1", "delta": ozet[:10]},
+                  {"type": "response.output_text.delta", "item_id": "msg_1", "delta": ozet[10:]},
+                  {"type": "response.output_item.done", "item": self._mesaj(ozet)},
+                  {"type": "response.completed", "response": {"id": "r1", "output": [self._mesaj(ozet)], "usage": {"input_tokens": 5}}})
+        a = o.OzetAkisi(tohum="7")
+        out = b"".join(a.feed(ham[i:i + 53]) for i in range(0, len(ham), 53)) + a.flush()
+        olaylar = coz(out)
+        self.assertEqual([e["type"] for e in olaylar], ["response.created", "response.output_item.done", "response.completed"])
+        oge = olaylar[1]["item"]
+        self.assertEqual(oge["type"], "compaction")
+        self.assertEqual(o.ozet_metni(oge), ozet)
+        self.assertEqual(olaylar[2]["response"]["output"], [oge])              # Codex tam bir compaction ogesi gorur
+        self.assertEqual(olaylar[2]["response"]["usage"], {"input_tokens": 5})
+        self.assertEqual(a.metin, ozet)
+        self.assertNotIn("KARAR-1", out.decode())                                # ozet metni akista duz gorunmez
+
+    def test_yalniz_delta_gelirse_de_toplanir(self):
+        ham = sse({"type": "response.created", "response": {}},
+                  {"type": "response.output_text.delta", "item_id": "a", "delta": "ozet "},
+                  {"type": "response.output_text.delta", "item_id": "a", "delta": "metni"},
+                  {"type": "response.completed", "response": {}})
+        a = o.OzetAkisi()
+        self.assertEqual(o.ozet_metni(coz(a.feed(ham))[1]["item"]), "ozet metni")
+
+    def test_anormal_kisa_ozet_gecmisin_yerine_konmaz(self):
+        # Esik yalniz bozuk sayilacak kadar kisa ozeti yakalar. 10 Ekim 2026 olcumu: 646.955 baytlik
+        # sohbetin dogru ozeti 1501-1701 karakterdi ve boyuta oranli eski esik onu reddedip sohbeti kilitledi.
+        self.assertEqual(o.en_az_karakter(1018151), 300)
+        self.assertEqual(o.en_az_karakter(646955), 300)
+        self.assertEqual(o.en_az_karakter(100000), 50)
+        self.assertEqual(o.en_az_karakter(0), 0)
+        self.assertEqual(o.en_az_karakter(1018151, {"en_az_tavan": 1500, "en_az_oran": 250}), 1500)
+        for gercek_ozet in (1501, 1648, 1701):
+            self.assertGreater(gercek_ozet, o.en_az_karakter(646955))
+        ham = sse({"type": "response.created", "response": {"id": "r1"}},
+                  {"type": "response.output_item.done", "item": self._mesaj("k" * 120)},
+                  {"type": "response.completed", "response": {"id": "r1", "status": "completed"}})
+        a = o.OzetAkisi(tohum="7", en_az=o.en_az_karakter(1018151))
+        olaylar = coz(a.feed(ham) + a.flush())
+        self.assertEqual([e["type"] for e in olaylar], ["response.created", "response.failed"])
+        self.assertNotIn("compaction", json.dumps(olaylar))
+        self.assertEqual(olaylar[1]["response"]["error"]["code"], "astrabridge_ozet_kisa")
+        self.assertTrue(a.kisa)
+        self.assertIn("REDDEDILDI", a.sonuc_notu())
+        # Yeterli uzunlukta ozet ayni esikle kabul edilir; kucuk sohbetin kisa ozeti de reddedilmez.
+        for metin, esik in (("u" * 1501, o.en_az_karakter(646955)), ("kisa ama dogru ozet", o.en_az_karakter(3000))):
+            b = o.OzetAkisi(tohum="8", en_az=esik)
+            ham2 = sse({"type": "response.output_item.done", "item": self._mesaj(metin)},
+                       {"type": "response.completed", "response": {"id": "r2"}})
+            cikti = coz(b.feed(ham2))
+            self.assertEqual(o.ozet_metni(cikti[0]["item"]), metin)
+            self.assertFalse(b.kisa)
+
+    def test_metin_yoksa_compaction_uretilmez_hata_gorunur(self):
+        ham = sse({"type": "response.created", "response": {}},
+                  {"type": "response.output_item.done", "item": {"type": "function_call", "name": "x"}},
+                  {"type": "response.completed", "response": {"output": []}})
+        a = o.OzetAkisi()
+        olaylar = coz(a.feed(ham))
+        self.assertNotIn("compaction", json.dumps(olaylar))
+        self.assertFalse(a.metin)
+        hata = sse({"type": "response.created", "response": {}}, {"type": "response.failed", "response": {"error": {"message": "x"}}})
+        self.assertIn("response.failed", o.OzetAkisi().feed(hata).decode())
+
+    def test_onbellek(self):
+        klasor = os.path.join(tempfile.mkdtemp(), "c")
+        self.assertIsNone(o.onbellekten(klasor, OPENAI_OZETI))
+        o.onbellege(klasor, OPENAI_OZETI, "duz metin ozet")
+        self.assertEqual(o.onbellekten(klasor, OPENAI_OZETI), "duz metin ozet")
+
+    def test_sse_metni(self):
+        ham = sse({"type": "response.created", "response": {}}, {"type": "response.output_item.done", "item": self._mesaj("cozulmus ozet")},
+                  {"type": "response.completed", "response": {}})
+        self.assertEqual(o.sse_metni(ham), "cozulmus ozet")
+
+
+class Fren(unittest.TestCase):
+    def test_tight_loop_is_stopped_but_spaced_summaries_are_not(self):
+        f = o.DonguFreni(sinir=8, pencere_sn=600, art_arda=3)
+        # Summary after summary with no normal request in between: a real loop.
+        self.assertEqual([f.izin("sohbet-a", t) for t in (0, 10, 20, 30, 40)], [True, True, True, False, False])
+        self.assertTrue(f.izin("sohbet-b", 40))                    # another conversation is unaffected
+        # A normal request between summaries (small-window model compacting every turn) keeps working.
+        g = o.DonguFreni(sinir=8, pencere_sn=600, art_arda=3)
+        izinler = []
+        for t in range(0, 70, 10):
+            izinler.append(g.izin("sohbet-c", t))
+            g.normal("sohbet-c")
+        self.assertEqual(izinler, [True] * 7)
+        self.assertTrue(g.izin("sohbet-c", 70))                    # the 8th in the window
+        g.normal("sohbet-c")
+        self.assertFalse(g.izin("sohbet-c", 80))                   # the total cap still ends a slow loop
+        self.assertTrue(g.izin("sohbet-c", 700))                   # and lifts once the window passes
+        self.assertIn("Dongu durduruldu", o.DONGU_MESAJI % 3)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,229 @@
+"""Bridge version 7: real context windows, phase stamping, overflow errors, images for vision models."""
+import ast
+import json
+import os
+import tempfile
+import unittest
+from pathlib import Path
+
+import ide_catalog as c
+import pencere
+import resim_context
+
+tree = ast.parse(Path(__file__).with_name("bridge.py").read_text(encoding="utf-8"))
+names = {"fix_tool_ids", "SseRewriter", "phase_damgala", "asistan_mesaji_mi"}
+nodes = [n for n in tree.body if isinstance(n, (ast.FunctionDef, ast.ClassDef)) and n.name in names]
+for node in tree.body:
+    if isinstance(node, ast.Assign) and any(isinstance(t, ast.Name) and t.id in
+            {"ID_PREFIX", "FOREIGN_ID_MARK", "REFERENCE_TYPES", "INLINE_TYPES", "ARAC_OGELERI"} for t in node.targets):
+        nodes.insert(0, node)
+env = {"json": json, "re": __import__("re"), "log": lambda message: None, "pencere": pencere}
+exec(compile(ast.Module(body=nodes, type_ignores=[]), "bridge.py", "exec"), env)
+
+NANO = pencere.nano_sadelestir({"data": [
+    {"id": "z-ai/glm-5.3-flash-uncensored", "context_length": 1048576,
+     "capabilities": {"vision": True, "tool_calling": True}},
+    {"id": "mlabonne/NeuralDaredevil-8B-abliterated", "context_length": 8192,
+     "capabilities": {"vision": False, "tool_calling": False}},
+    {"id": "nousresearch/hermes-3-llama-3.1-70b", "context_length": 65536,
+     "capabilities": {"vision": False, "tool_calling": True}},
+    {"id": "broken", "context_length": 0}]})
+
+
+def sse(*events):
+    return b"".join(b"event: " + e["type"].encode() + b"\ndata: " + json.dumps(e).encode() + b"\n\n" for e in events)
+
+
+def parse(raw):
+    return [json.loads(line[6:]) for line in raw.decode().splitlines() if line.startswith("data: ")]
+
+
+def message(text, ident="msg_1"):
+    return {"type": "message", "id": ident, "role": "assistant", "content": [{"type": "output_text", "text": text}]}
+
+
+class Windows(unittest.TestCase):
+    def test_provider_data_local_table_and_cap(self):
+        coz = pencere.coz
+        # The provider that carries the request decides; nothing is declared above the summarizer's window.
+        self.assertEqual(coz("9router-nano-z-ai-glm-5.3-flash-uncensored", "model", "nano/z-ai/glm-5.3-flash-uncensored",
+                             nano=NANO)["pencere"], pencere.TAVAN)
+        small = coz("9router-nano-mlabonne-NeuralDaredevil-8B-abliterated", "model",
+                    "nano/mlabonne/NeuralDaredevil-8B-abliterated", nano=NANO)
+        self.assertEqual((small["pencere"], small["arac"], small["gorsel"]), (8192, False, False))
+        self.assertEqual(coz("9router-cc-claude-opus-5-5", "model", "cc/claude-opus-5-5")["pencere"], 200000)
+        self.assertEqual(coz("9router-cx-gpt-6-astra", "model", "cx/gpt-6-astra")["pencere"], 272000)
+        self.assertEqual(coz("no-think-9router-cc-claude-opus-5-5", "model", "no-think/claude-opus-5-5")["pencere"], 200000)
+        unknown = coz("agnes-agnes-2.5-flash", "model", "Agnes 2.5 Flash", nano=NANO)
+        self.assertEqual((unknown["pencere"], unknown["kaynak"]), (pencere.VARSAYILAN, "varsayilan"))
+        self.assertNotIn("broken", NANO)
+
+    def test_combo_declares_its_smallest_member(self):
+        combo = {"topology": {"kind": "combo", "strategy": "priority", "members": [
+            {"kind": "model", "model": "cx/gpt-6-astra"},
+            {"kind": "combo", "strategy": "priority", "members": [
+                {"kind": "model", "model": "nano/z-ai/glm-5.3-flash-uncensored"},
+                {"kind": "model", "model": "nano/nousresearch/hermes-3-llama-3.1-70b"}]}]}}
+        self.assertEqual(pencere.coz("X", "combo", "X", combo, NANO)["pencere"], 65536)
+        self.assertEqual(pencere.coz("X", "combo", "X", None, NANO)["pencere"], pencere.VARSAYILAN)
+
+    def test_limit_learned_from_the_target_error_only_shrinks(self):
+        home = tempfile.mkdtemp()
+        text = "This model's maximum context length is 32768 tokens. However, you requested 51234 tokens"
+        self.assertTrue(pencere.tasma_mi(text))
+        self.assertEqual(pencere.sinir_oku(text), 32768)
+        self.assertEqual(pencere.sinir_oku("prompt is too long: 3040251 tokens > 1000000 maximum"), 1000000)
+        gateway = ("Your prompt exceeds the model's context length. Estimated input tokens: 171016. "
+                   "Max context tokens: 65536.")
+        self.assertTrue(pencere.tasma_mi(gateway))
+        self.assertEqual(pencere.sinir_oku(gateway), 65536)
+        self.assertIsNone(pencere.sinir_oku("rate limit exceeded"))
+        self.assertFalse(pencere.tasma_mi("rate limit exceeded"))
+        self.assertTrue(pencere.ogren(home, "m", 32768))
+        self.assertFalse(pencere.ogren(home, "m", 65536))          # a larger number never overrides
+        self.assertEqual(pencere.ogrenilen(home), {"m": 32768})
+        self.assertEqual(pencere.coz("m", "model", "cc/claude-opus-5-5", ogr=pencere.ogrenilen(home))["pencere"], 32768)
+
+    def test_nano_cache_survives_a_network_failure(self):
+        home = tempfile.mkdtemp()
+        fresh = {"data": [{"id": "A/b", "context_length": 16384, "capabilities": {}}]}
+        self.assertEqual(pencere.nano_yukle(home, simdi=1000, getir=lambda: fresh)["a/b"]["pencere"], 16384)
+
+        def fail():
+            raise OSError("offline")
+        later = 1000 + pencere.NANO_OMUR_SN + 5
+        self.assertEqual(pencere.nano_yukle(home, simdi=later, getir=fail)["a/b"]["pencere"], 16384)
+        self.assertEqual(pencere.nano_yukle(tempfile.mkdtemp(), simdi=later, getir=fail), {})
+        self.assertEqual((pencere.kisa(8192), pencere.kisa(131072), pencere.kisa(200000)), ("8K", "128K", "200K"))
+
+    def test_description_line_warns_about_small_window_and_no_tools(self):
+        bilgi = {"pencere": 8192, "arac": False, "gorsel": False}
+        line = c.aciklama("9router-nano-mlabonne-NeuralDaredevil-8B-abliterated", "9R · nano/NeuralDaredevil-8B-abliterated",
+                          "model", None, bilgi)
+        self.assertEqual(line, "NanoGPT · 8K · araçsız")           # warnings first; the rest no longer fits in 30
+        self.assertLessEqual(len(line), c.ACIKLAMA_SINIRI)
+        self.assertEqual(c.aciklama("9router-cc-claude-opus-5-5", "9R · cc/claude-opus-5-5", "model", None,
+                                    {"pencere": 200000, "arac": True, "gorsel": True}), "Tek model · Claude")
+
+
+class Guard(unittest.TestCase):
+    def req(self, old, last="son soru"):
+        return {"instructions": "talimat", "input": [
+            {"type": "message", "role": "user", "content": [{"type": "input_text", "text": old}]},
+            {"type": "function_call_output", "call_id": "c", "output": "cikti " * 4000},
+            {"type": "message", "role": "user", "content": [{"type": "input_text", "text": last}]}]}
+
+    def test_request_that_fits_is_untouched(self):
+        req = self.req("kisa")
+        before = json.dumps(req)
+        self.assertEqual(pencere.sigdir(req, 272000)[:2], (0, True))
+        self.assertEqual(json.dumps(req), before)
+
+    def test_oversized_old_parts_lose_their_middle_and_the_last_user_message_never_does(self):
+        req = self.req("BAS " + "dolgu " * 60000 + " SON", last="yeni " * 3000)
+        kirpilan, sigdi, tahmin = pencere.sigdir(req, 65536)
+        self.assertTrue(sigdi)
+        self.assertGreaterEqual(kirpilan, 1)
+        old = req["input"][0]["content"][0]["text"]
+        self.assertTrue(old.startswith("BAS ") and old.endswith(" SON"))
+        self.assertIn("çıkarıldı (köprü)", old)
+        self.assertEqual(req["input"][2]["content"][0]["text"], "yeni " * 3000)      # the new message is intact
+        self.assertLessEqual(tahmin, int(65536 * pencere.DOLULUK))
+
+    def test_a_last_message_larger_than_the_window_is_reported_not_sent(self):
+        req = self.req("kisa", last="x" * 400000)
+        self.assertFalse(pencere.sigdir(req, 32768)[1])
+
+
+class Phase(unittest.TestCase):
+    def run_stream(self, *events, chunk=37):
+        adapter = env["SseRewriter"](set())
+        raw = sse(*events)
+        out = b"".join(adapter.feed(raw[i:i + chunk]) for i in range(0, len(raw), chunk)) + adapter.flush()
+        return parse(out)
+
+    def test_message_before_a_tool_call_is_commentary(self):
+        call = {"type": "function_call", "id": "fc_1", "call_id": "call_1", "name": "shell", "arguments": "{}"}
+        out = self.run_stream(
+            {"type": "response.output_item.added", "item": message("")},
+            {"type": "response.output_text.delta", "item_id": "msg_1", "delta": "bakiyorum"},
+            {"type": "response.output_item.done", "item": message("bakiyorum")},
+            {"type": "response.output_item.added", "item": call},
+            {"type": "response.output_item.done", "item": call},
+            {"type": "response.completed", "response": {"output": [message("bakiyorum"), call]}})
+        self.assertEqual([e["type"] for e in out], [
+            "response.output_item.added", "response.output_text.delta", "response.output_item.done",
+            "response.output_item.added", "response.output_item.done", "response.completed"])     # order kept
+        self.assertEqual(out[2]["item"]["phase"], "commentary")
+        self.assertEqual(out[5]["response"]["output"][0]["phase"], "commentary")
+        self.assertNotIn("phase", out[5]["response"]["output"][1])
+
+    def test_last_message_without_tool_calls_is_the_final_answer(self):
+        out = self.run_stream(
+            {"type": "response.output_item.done", "item": message("ara", "msg_a")},
+            {"type": "response.output_item.added", "item": message("", "msg_b")},
+            {"type": "response.output_item.done", "item": message("son", "msg_b")},
+            {"type": "response.completed", "response": {"output": [message("ara", "msg_a"), message("son", "msg_b")]}})
+        done = [e for e in out if e["type"] == "response.output_item.done"]
+        self.assertEqual([e["item"]["phase"] for e in done], ["commentary", "final_answer"])
+        self.assertEqual([o["phase"] for o in out[-1]["response"]["output"]], ["commentary", "final_answer"])
+        self.assertEqual(out[-1]["type"], "response.completed")                                 # done comes first
+
+    def test_existing_phase_and_cut_streams_are_left_alone(self):
+        native = dict(message("x"), phase="final_answer")
+        out = self.run_stream({"type": "response.output_item.done", "item": native},
+                              {"type": "response.completed", "response": {"output": [dict(native)]}})
+        self.assertEqual(out[0]["item"]["phase"], "final_answer")
+        # No terminal event: the held message is still delivered, unmarked rather than guessed.
+        cut = self.run_stream({"type": "response.output_item.done", "item": message("yarim")})
+        self.assertEqual(len(cut), 1)
+        self.assertNotIn("phase", cut[0]["item"])
+
+    def test_overflow_failure_gets_the_code_codex_understands(self):
+        seen = []
+        adapter = env["SseRewriter"](set(), hedef="model-x", tasma=lambda hedef, metin: seen.append((hedef, metin)))
+        failed = {"type": "response.failed", "response": {"error": {
+            "code": "server_error", "message": "maximum context length is 32768 tokens"}}}
+        out = parse(adapter.feed(sse(failed)) + adapter.flush())
+        self.assertEqual(out[0]["response"]["error"]["code"], "context_length_exceeded")
+        self.assertEqual(seen[0][0], "model-x")
+        other = {"type": "response.failed", "response": {"error": {"code": "rate_limit", "message": "slow down"}}}
+        self.assertEqual(parse(adapter.feed(sse(other)))[0]["response"]["error"]["code"], "rate_limit")
+
+
+class GatewayErrors(unittest.TestCase):
+    def test_permanent_gateway_error_becomes_a_failure_codex_shows_at_once(self):
+        adapter = env["SseRewriter"](set())
+        raw = sse({"type": "error", "error": {"type": "upstream_error", "message": "upstream 402"}})
+        out = parse(adapter.feed(raw) + adapter.flush())
+        self.assertEqual(out[0]["type"], "response.failed")
+        self.assertEqual(out[0]["response"]["error"]["code"], "insufficient_quota")
+        self.assertIn("upstream 402", out[0]["response"]["error"]["message"])
+        # A transient error is left alone so that Codex retries it.
+        raw = sse({"type": "error", "error": {"type": "upstream_error", "message": "upstream 503"}})
+        self.assertEqual(parse(env["SseRewriter"](set()).feed(raw))[0]["type"], "error")
+
+
+class Images(unittest.TestCase):
+    def req(self):
+        img = {"type": "input_image", "image_url": "data:image/png;base64," + "A" * 2000}
+        return {"input": [
+            {"type": "message", "role": "user", "content": [{"type": "input_text", "text": "bak"}, dict(img)]},
+            {"type": "message", "role": "assistant", "content": [{"type": "output_text", "text": "OKUDUM"}]},
+            {"type": "function_call_output", "call_id": "c", "output": [dict(img)]},
+            {"type": "message", "role": "user", "content": [{"type": "input_text", "text": "ne yaziyordu"}]}]}
+
+    def test_text_model_gets_notes_vision_model_keeps_user_images(self):
+        text_only = self.req()
+        self.assertEqual(resim_context.resimleri_sadelestir(text_only)[0], 2)
+        self.assertNotIn("input_image", json.dumps(text_only))
+        vision = self.req()
+        self.assertEqual(resim_context.resimleri_sadelestir(vision, gorsel=True)[0], 1)   # only the tool output
+        self.assertEqual(vision["input"][0]["content"][1]["type"], "input_image")
+        self.assertNotIn("input_image", json.dumps(vision["input"][2]))
+        big = self.req()
+        self.assertEqual(resim_context.resimleri_sadelestir(big, tut_bayt=500, gorsel=True)[0], 2)   # over budget
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,71 @@
+"""py -3 -m unittest test_resim_context  (astra-bridge klasöründe)"""
+import unittest
+
+from resim_context import resimleri_sadelestir
+
+
+def resim(bayt):
+    return {'type': 'input_image', 'image_url': 'data:image/png;base64,' + 'A' * bayt}
+
+
+class Resim(unittest.TestCase):
+    def test_generated_image_in_tool_output_is_replaced(self):
+        req = {'input': [
+            {'type': 'message', 'role': 'user', 'content': [{'type': 'input_text', 'text': 'foto'}, resim(150_000)]},
+            {'type': 'custom_tool_call_output', 'call_id': 'x',
+             'output': [{'type': 'input_text', 'text': 'tamam'}, resim(3_000_000)]},
+        ]}
+        sayi, kazanc = resimleri_sadelestir(req)
+        self.assertEqual(sayi, 1)  # son user mesajındaki küçük foto korunur, araç çıktısındaki resim çıkar
+        self.assertGreater(kazanc, 3_000_000)
+        self.assertEqual(req['input'][1]['output'][1]['type'], 'input_text')
+
+    def test_latest_user_photos_kept_when_small(self):
+        req = {'input': [
+            {'type': 'message', 'role': 'user', 'content': [resim(10_000)]},
+            {'type': 'message', 'role': 'assistant', 'content': [{'type': 'output_text', 'text': 'ok'}]},
+            {'type': 'message', 'role': 'user', 'content': [{'type': 'input_text', 'text': 'yeni'}, resim(200_000)]},
+        ]}
+        sayi, _ = resimleri_sadelestir(req)
+        self.assertEqual(sayi, 1)  # yalnız eski mesajdaki resim
+        self.assertEqual(req['input'][2]['content'][1]['type'], 'input_image')
+        self.assertEqual(req['input'][0]['content'][0]['type'], 'input_text')
+
+    def test_latest_user_photos_dropped_when_too_big(self):
+        req = {'input': [{'type': 'message', 'role': 'user', 'content': [resim(1_200_000)]}]}
+        self.assertEqual(resimleri_sadelestir(req)[0], 1)
+
+    def test_pdf_audio_video_in_old_messages_and_tool_output_are_replaced(self):
+        pdf = {'type': 'input_file', 'filename': 'rapor.pdf', 'file_data': 'data:application/pdf;base64,' + 'P' * 500_000}
+        ses = {'type': 'input_audio', 'input_audio': {'data': 'S' * 400_000, 'format': 'wav'}}
+        video = {'type': 'input_video', 'video_url': 'data:video/mp4;base64,' + 'V' * 300_000}
+        req = {'input': [
+            {'type': 'message', 'role': 'user', 'content': [pdf, ses]},
+            {'type': 'function_call_output', 'call_id': 'y', 'output': [video]},
+            {'type': 'message', 'role': 'user', 'content': [{'type': 'input_text', 'text': 'devam'}]},
+        ]}
+        sayi, _ = resimleri_sadelestir(req)
+        self.assertEqual(sayi, 3)
+        self.assertIn('rapor.pdf', req['input'][0]['content'][0]['text'])
+        self.assertIn('ses', req['input'][0]['content'][1]['text'])
+        self.assertIn('video', req['input'][1]['output'][0]['text'])
+
+    def test_huge_text_tool_output_is_shortened(self):
+        req = {'input': [{'type': 'function_call_output', 'call_id': 'z', 'output': 'x' * 3_000_000}]}
+        sayi, kazanc = resimleri_sadelestir(req)
+        self.assertEqual(sayi, 1)
+        self.assertLess(len(req['input'][0]['output']), 600_000)
+        self.assertIn('çıkarıldı', req['input'][0]['output'])
+
+    def test_unknown_huge_part_is_replaced(self):
+        req = {'input': [{'type': 'custom_tool_call_output', 'call_id': 'q',
+                          'output': [{'type': 'yeni_bir_tur', 'veri': 'Z' * 1_500_000}]}]}
+        self.assertEqual(resimleri_sadelestir(req)[0], 1)
+
+    def test_request_without_images_untouched(self):
+        req = {'input': [{'type': 'message', 'role': 'user', 'content': [{'type': 'input_text', 'text': 'x'}]}]}
+        self.assertEqual(resimleri_sadelestir(req), (0, 0))
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,74 @@
+"""An answer cut by the client is carried to the next turn of the same conversation, once."""
+import json
+import unittest
+
+import yarim
+
+
+def delta(text):
+    return (b"event: response.output_text.delta\ndata: "
+            + json.dumps({"type": "response.output_text.delta", "delta": text}).encode() + b"\n\n")
+
+
+def user(text):
+    return {"type": "message", "role": "user", "content": [{"type": "input_text", "text": text}]}
+
+
+class Yarim(unittest.TestCase):
+    def setUp(self):
+        yarim._KAYIT.clear()
+
+    def cut(self, key="sohbet-1", text="1. bir sayidir ve ilk siradadir. 2. iki sayidir ve cifttir. 3. uc"):
+        izle = yarim.Izleyici(key, "ide/x")
+        raw = delta(text[:20]) + delta(text[20:])
+        for i in range(0, len(raw), 17):
+            izle.feed(raw[i:i + 17])
+        return izle
+
+    def test_cut_answer_reaches_the_next_user_message_once(self):
+        izle = self.cut()
+        self.assertTrue(yarim.kaydet(izle, simdi=100))
+        req = {"input": [user("liste yaz"), user("kaldigin yerden devam et")]}
+        self.assertGreater(yarim.uygula(req, "sohbet-1", simdi=200), 0)
+        note = req["input"][-1]["content"][-1]["text"]
+        self.assertIn("3. uc", note)
+        self.assertIn('model="ide/x"', note)
+        self.assertEqual(req["input"][-1]["content"][0]["text"], "kaldigin yerden devam et")   # the user's words stay first
+        again = {"input": [user("bir daha")]}
+        self.assertEqual(yarim.uygula(again, "sohbet-1", simdi=300), 0)                        # used once
+        self.assertEqual(yarim.uygula({"input": [user("x")]}, "baska-sohbet", simdi=300), 0)
+
+    def test_finished_short_or_keyless_answers_are_not_kept(self):
+        done = self.cut()
+        done.feed(b'event: response.completed\ndata: {"type": "response.completed"}\n\n')
+        self.assertFalse(yarim.kaydet(done))
+        self.assertFalse(yarim.kaydet(self.cut(text="kisa")))
+        self.assertFalse(yarim.kaydet(self.cut(key="")))
+
+    def test_note_waits_for_a_real_user_turn_and_skips_text_codex_already_saved(self):
+        yarim.kaydet(self.cut(), simdi=100)
+        tool_turn = {"input": [user("x"), {"type": "function_call_output", "call_id": "c", "output": "ok"}]}
+        self.assertEqual(yarim.uygula(tool_turn, "sohbet-1", simdi=110), 0)
+        compaction = {"input": [user("x"), {"type": "compaction_trigger"}]}
+        self.assertEqual(yarim.uygula(compaction, "sohbet-1", simdi=110), 0)
+        self.assertIn("sohbet-1", yarim._KAYIT)                                   # still waiting
+        saved = {"input": [{"type": "message", "role": "assistant", "content": [
+            {"type": "output_text", "text": "1. bir sayidir ve ilk siradadir. 2. iki sayidir ve cifttir. 3. uc"}]}, user("devam")]}
+        self.assertEqual(yarim.uygula(saved, "sohbet-1", simdi=120), 0)
+        self.assertNotIn("sohbet-1", yarim._KAYIT)
+        yarim.kaydet(self.cut(), simdi=100)
+        self.assertEqual(yarim.uygula({"input": [user("gec")]}, "sohbet-1", simdi=100 + yarim.OMUR_SN + 1), 0)   # expired
+
+    def test_long_text_keeps_head_and_tail(self):
+        yarim.kaydet(self.cut(text="BAS" + "x" * 40000 + "SON"), simdi=1)
+        req = {"input": [user("devam")]}
+        yarim.uygula(req, "sohbet-1", simdi=2)
+        note = req["input"][-1]["content"][-1]["text"]
+        self.assertLess(len(note), yarim.EN_COK_KARAKTER + 600)
+        self.assertIn("BAS", note)
+        self.assertTrue(note.rstrip().endswith("</yarim_cevap>"))
+        self.assertIn("SON\n</yarim_cevap>", note)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,35 @@
+"""Codex compresses request bodies with zstd; the bridge must be able to read them."""
+import ast
+import unittest
+from pathlib import Path
+
+tree = ast.parse(Path(__file__).with_name("bridge.py").read_text(encoding="utf-8"))
+wanted = {"_zstd_decompress", "_zstd_ready", "decompress"}
+env = {}
+exec(compile(ast.Module(body=[n for n in tree.body if isinstance(n, ast.FunctionDef) and n.name in wanted],
+                        type_ignores=[]), "bridge.py", "exec"), env)
+
+
+class Zstd(unittest.TestCase):
+    def test_self_check_matches_reality(self):
+        try:
+            try:
+                from compression import zstd as z
+                packed = z.compress(b"govde" * 50)
+            except ImportError:
+                import zstandard
+                packed = zstandard.ZstdCompressor().compress(b"govde" * 50)
+        except ImportError:
+            self.assertFalse(env["_zstd_ready"]())      # no zstd here: the bridge must say so
+            return
+        self.assertTrue(env["_zstd_ready"]())
+        self.assertEqual(env["decompress"](packed, "zstd"), b"govde" * 50)
+
+    def test_other_encodings(self):
+        import gzip
+        self.assertEqual(env["decompress"](gzip.compress(b"x"), "gzip"), b"x")
+        self.assertEqual(env["decompress"](b"duz", None), b"duz")
+
+
+if __name__ == "__main__":
+    unittest.main()

apps/desktop/assets/codex-bridge/vendor/cp311-win_amd64/zstandard-0.25.0.dist-info/licenses/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2016, Gregory Szorc
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors
+may be used to endorse or promote products derived from this software without
+specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

apps/desktop/assets/codex-bridge/vendor/cp311-win_amd64/zstandard/__init__.py

@@ -0,0 +1,217 @@
+# Copyright (c) 2017-present, Gregory Szorc
+# All rights reserved.
+#
+# This software may be modified and distributed under the terms
+# of the BSD license. See the LICENSE file for details.
+
+# ruff: noqa: F403, F405
+
+"""Python interface to the Zstandard (zstd) compression library."""
+
+from __future__ import absolute_import, unicode_literals
+
+# This module serves 2 roles:
+#
+# 1) Export the C or CFFI "backend" through a central module.
+# 2) Implement additional functionality built on top of C or CFFI backend.
+import builtins
+import io
+import os
+import platform
+import sys
+
+if sys.version_info >= (3, 12):
+    from collections.abc import Buffer
+else:
+    from typing import ByteString as Buffer
+
+# Some Python implementations don't support C extensions. That's why we have
+# a CFFI implementation in the first place. The code here import one of our
+# "backends" then re-exports the symbols from this module. For convenience,
+# we support falling back to the CFFI backend if the C extension can't be
+# imported. But for performance reasons, we only do this on unknown Python
+# implementation. Notably, for CPython we require the C extension by default.
+# Because someone will inevitably want special behavior, the behavior is
+# configurable via an environment variable. A potentially better way to handle
+# this is to import a special ``__importpolicy__`` module or something
+# defining a variable and `setup.py` could write the file with whatever
+# policy was specified at build time. Until someone needs it, we go with
+# the hacky but simple environment variable approach.
+_module_policy = os.environ.get(
+    "PYTHON_ZSTANDARD_IMPORT_POLICY", "default"
+).strip()
+
+if _module_policy == "default":
+    if platform.python_implementation() in ("CPython",):
+        from .backend_c import *  # type: ignore
+
+        backend = "cext"
+    elif platform.python_implementation() in ("PyPy",):
+        from .backend_cffi import *  # type: ignore
+
+        backend = "cffi"
+    else:
+        try:
+            from .backend_c import *
+
+            backend = "cext"
+        except ImportError:
+            from .backend_cffi import *
+
+            backend = "cffi"
+elif _module_policy == "cffi_fallback":
+    try:
+        from .backend_c import *
+
+        backend = "cext"
+    except ImportError:
+        from .backend_cffi import *
+
+        backend = "cffi"
+elif _module_policy == "rust":
+    from .backend_rust import *  # type: ignore
+
+    backend = "rust"
+elif _module_policy == "cext":
+    from .backend_c import *
+
+    backend = "cext"
+elif _module_policy == "cffi":
+    from .backend_cffi import *
+
+    backend = "cffi"
+else:
+    raise ImportError(
+        "unknown module import policy: %s; use default, cffi_fallback, "
+        "cext, or cffi" % _module_policy
+    )
+
+# Keep this in sync with python-zstandard.h, rust-ext/src/lib.rs, and debian/changelog.
+__version__ = "0.25.0"
+
+_MODE_CLOSED = 0
+_MODE_READ = 1
+_MODE_WRITE = 2
+
+
+def open(
+    filename,
+    mode="rb",
+    cctx=None,
+    dctx=None,
+    encoding=None,
+    errors=None,
+    newline=None,
+    closefd=None,
+):
+    """Create a file object with zstd (de)compression.
+
+    The object returned from this function will be a
+    :py:class:`ZstdDecompressionReader` if opened for reading in binary mode,
+    a :py:class:`ZstdCompressionWriter` if opened for writing in binary mode,
+    or an ``io.TextIOWrapper`` if opened for reading or writing in text mode.
+
+    :param filename:
+       ``bytes``, ``str``, or ``os.PathLike`` defining a file to open or a
+       file object (with a ``read()`` or ``write()`` method).
+    :param mode:
+       ``str`` File open mode. Accepts any of the open modes recognized by
+       ``open()``.
+    :param cctx:
+       ``ZstdCompressor`` to use for compression. If not specified and file
+       is opened for writing, the default ``ZstdCompressor`` will be used.
+    :param dctx:
+       ``ZstdDecompressor`` to use for decompression. If not specified and file
+       is opened for reading, the default ``ZstdDecompressor`` will be used.
+    :param encoding:
+        ``str`` that defines text encoding to use when file is opened in text
+        mode.
+    :param errors:
+       ``str`` defining text encoding error handling mode.
+    :param newline:
+       ``str`` defining newline to use in text mode.
+    :param closefd:
+       ``bool`` whether to close the file when the returned object is closed.
+        Only used if a file object is passed. If a filename is specified, the
+        opened file is always closed when the returned object is closed.
+    """
+    normalized_mode = mode.replace("t", "")
+
+    if normalized_mode in ("r", "rb"):
+        dctx = dctx or ZstdDecompressor()
+        open_mode = "r"
+        raw_open_mode = "rb"
+    elif normalized_mode in ("w", "wb", "a", "ab", "x", "xb"):
+        cctx = cctx or ZstdCompressor()
+        open_mode = "w"
+        raw_open_mode = normalized_mode
+        if not raw_open_mode.endswith("b"):
+            raw_open_mode = raw_open_mode + "b"
+    else:
+        raise ValueError("Invalid mode: {!r}".format(mode))
+
+    if hasattr(os, "PathLike"):
+        types = (str, bytes, os.PathLike)
+    else:
+        types = (str, bytes)
+
+    if isinstance(filename, types):  # type: ignore
+        inner_fh = builtins.open(filename, raw_open_mode)
+        closefd = True
+    elif hasattr(filename, "read") or hasattr(filename, "write"):
+        inner_fh = filename
+        closefd = bool(closefd)
+    else:
+        raise TypeError(
+            "filename must be a str, bytes, file or PathLike object"
+        )
+
+    if open_mode == "r":
+        fh = dctx.stream_reader(inner_fh, closefd=closefd)
+    elif open_mode == "w":
+        fh = cctx.stream_writer(inner_fh, closefd=closefd)
+    else:
+        raise RuntimeError("logic error in zstandard.open() handling open mode")
+
+    if "b" not in normalized_mode:
+        return io.TextIOWrapper(
+            fh, encoding=encoding, errors=errors, newline=newline
+        )
+    else:
+        return fh
+
+
+def compress(data: Buffer, level: int = 3) -> bytes:
+    """Compress source data using the zstd compression format.
+
+    This performs one-shot compression using basic/default compression
+    settings.
+
+    This method is provided for convenience and is equivalent to calling
+    ``ZstdCompressor(level=level).compress(data)``.
+
+    If you find yourself calling this function in a tight loop,
+    performance will be greater if you construct a single ``ZstdCompressor``
+    and repeatedly call ``compress()`` on it.
+    """
+    cctx = ZstdCompressor(level=level)
+
+    return cctx.compress(data)
+
+
+def decompress(data: Buffer, max_output_size: int = 0) -> bytes:
+    """Decompress a zstd frame into its original data.
+
+    This performs one-shot decompression using basic/default compression
+    settings.
+
+    This method is provided for convenience and is equivalent to calling
+    ``ZstdDecompressor().decompress(data, max_output_size=max_output_size)``.
+
+    If you find yourself calling this function in a tight loop, performance
+    will be greater if you construct a single ``ZstdDecompressor`` and
+    repeatedly call ``decompress()`` on it.
+    """
+    dctx = ZstdDecompressor()
+
+    return dctx.decompress(data, max_output_size=max_output_size)

apps/desktop/assets/codex-bridge/vendor/cp311-win_amd64/zstandard/__init__.pyi

@@ -0,0 +1,481 @@
+# Copyright (c) 2016-present, Gregory Szorc
+# All rights reserved.
+#
+# This software may be modified and distributed under the terms
+# of the BSD license. See the LICENSE file for details.
+
+import os
+from typing import (
+    IO,
+    BinaryIO,
+    ByteString,
+    Generator,
+    Iterable,
+    List,
+    Optional,
+    Set,
+    Tuple,
+    Union,
+)
+
+FLUSH_BLOCK: int
+FLUSH_FRAME: int
+
+COMPRESSOBJ_FLUSH_FINISH: int
+COMPRESSOBJ_FLUSH_BLOCK: int
+
+CONTENTSIZE_UNKNOWN: int
+CONTENTSIZE_ERROR: int
+
+MAX_COMPRESSION_LEVEL: int
+
+COMPRESSION_RECOMMENDED_INPUT_SIZE: int
+COMPRESSION_RECOMMENDED_OUTPUT_SIZE: int
+
+DECOMPRESSION_RECOMMENDED_INPUT_SIZE: int
+DECOMPRESSION_RECOMMENDED_OUTPUT_SIZE: int
+
+BLOCKSIZELOG_MAX: int
+BLOCKSIZE_MAX: int
+
+WINDOWLOG_MIN: int
+WINDOWLOG_MAX: int
+
+CHAINLOG_MIN: int
+CHAINLOG_MAX: int
+HASHLOG_MIN: int
+HASHLOG_MAX: int
+MINMATCH_MIN: int
+MINMATCH_MAX: int
+SEARCHLOG_MIN: int
+SEARCHLOG_MAX: int
+SEARCHLENGTH_MIN: int
+SEARCHLENGTH_MAX: int
+TARGETLENGTH_MIN: int
+TARGETLENGTH_MAX: int
+LDM_MINMATCH_MIN: int
+LDM_MINMATCH_MAX: int
+LDM_BUCKETSIZELOG_MAX: int
+
+STRATEGY_FAST: int
+STRATEGY_DFAST: int
+STRATEGY_GREEDY: int
+STRATEGY_LAZY: int
+STRATEGY_LAZY2: int
+STRATEGY_BTLAZY2: int
+STRATEGY_BTOPT: int
+STRATEGY_BTULTRA: int
+STRATEGY_BTULTRA2: int
+
+DICT_TYPE_AUTO: int
+DICT_TYPE_RAWCONTENT: int
+DICT_TYPE_FULLDICT: int
+
+FORMAT_ZSTD1: int
+FORMAT_ZSTD1_MAGICLESS: int
+
+ZSTD_VERSION: Tuple[int, int, int]
+FRAME_HEADER: bytes
+MAGIC_NUMBER: int
+
+backend: str
+backend_features: Set[str]
+__version__: str
+
+class ZstdError(Exception): ...
+
+class BufferSegment(object):
+    offset: int
+    def __len__(self) -> int: ...
+    def tobytes(self) -> bytes: ...
+
+class BufferSegments(object):
+    def __len__(self) -> int: ...
+    def __getitem__(self, i: int) -> BufferSegment: ...
+
+class BufferWithSegments(object):
+    size: int
+    def __init__(self, data: ByteString, segments: ByteString): ...
+    def __len__(self) -> int: ...
+    def __getitem__(self, i: int) -> BufferSegment: ...
+    def segments(self): ...
+    def tobytes(self) -> bytes: ...
+
+class BufferWithSegmentsCollection(object):
+    def __init__(self, *args): ...
+    def __len__(self) -> int: ...
+    def __getitem__(self, i: int) -> BufferSegment: ...
+    def size(self) -> int: ...
+
+class ZstdCompressionParameters(object):
+    @staticmethod
+    def from_level(
+        level: int, source_size: int = ..., dict_size: int = ..., **kwargs
+    ) -> "ZstdCompressionParameters": ...
+    def __init__(
+        self,
+        format: int = ...,
+        compression_level: int = ...,
+        window_log: int = ...,
+        hash_log: int = ...,
+        chain_log: int = ...,
+        search_log: int = ...,
+        min_match: int = ...,
+        target_length: int = ...,
+        strategy: int = ...,
+        write_content_size: int = ...,
+        write_checksum: int = ...,
+        write_dict_id: int = ...,
+        job_size: int = ...,
+        overlap_log: int = ...,
+        force_max_window: int = ...,
+        enable_ldm: int = ...,
+        ldm_hash_log: int = ...,
+        ldm_min_match: int = ...,
+        ldm_bucket_size_log: int = ...,
+        ldm_hash_rate_log: int = ...,
+        threads: int = ...,
+    ): ...
+    @property
+    def format(self) -> int: ...
+    @property
+    def compression_level(self) -> int: ...
+    @property
+    def window_log(self) -> int: ...
+    @property
+    def hash_log(self) -> int: ...
+    @property
+    def chain_log(self) -> int: ...
+    @property
+    def search_log(self) -> int: ...
+    @property
+    def min_match(self) -> int: ...
+    @property
+    def target_length(self) -> int: ...
+    @property
+    def strategy(self) -> int: ...
+    @property
+    def write_content_size(self) -> int: ...
+    @property
+    def write_checksum(self) -> int: ...
+    @property
+    def write_dict_id(self) -> int: ...
+    @property
+    def job_size(self) -> int: ...
+    @property
+    def overlap_log(self) -> int: ...
+    @property
+    def force_max_window(self) -> int: ...
+    @property
+    def enable_ldm(self) -> int: ...
+    @property
+    def ldm_hash_log(self) -> int: ...
+    @property
+    def ldm_min_match(self) -> int: ...
+    @property
+    def ldm_bucket_size_log(self) -> int: ...
+    @property
+    def ldm_hash_rate_log(self) -> int: ...
+    @property
+    def threads(self) -> int: ...
+    def estimated_compression_context_size(self) -> int: ...
+
+class CompressionParameters(ZstdCompressionParameters): ...
+
+class ZstdCompressionDict(object):
+    k: int
+    d: int
+    def __init__(
+        self,
+        data: ByteString,
+        dict_type: int = ...,
+        k: int = ...,
+        d: int = ...,
+    ): ...
+    def __len__(self) -> int: ...
+    def dict_id(self) -> int: ...
+    def as_bytes(self) -> bytes: ...
+    def precompute_compress(
+        self,
+        level: int = ...,
+        compression_params: ZstdCompressionParameters = ...,
+    ): ...
+
+class ZstdCompressionObj(object):
+    def compress(self, data: ByteString) -> bytes: ...
+    def flush(self, flush_mode: int = ...) -> bytes: ...
+
+class ZstdCompressionChunker(object):
+    def compress(self, data: ByteString): ...
+    def flush(self): ...
+    def finish(self): ...
+
+class ZstdCompressionReader(BinaryIO):
+    def __enter__(self) -> "ZstdCompressionReader": ...
+    def __exit__(self, exc_type, exc_value, exc_tb): ...
+    def readable(self) -> bool: ...
+    def writable(self) -> bool: ...
+    def seekable(self) -> bool: ...
+    def readline(self, limit: int = ...) -> bytes: ...
+    def readlines(self, hint: int = ...) -> List[bytes]: ...
+    def write(self, data: ByteString): ...
+    def writelines(self, data: Iterable[bytes]): ...
+    def isatty(self) -> bool: ...
+    def flush(self): ...
+    def close(self): ...
+    @property
+    def closed(self) -> bool: ...
+    def tell(self) -> int: ...
+    def readall(self) -> bytes: ...
+    def __iter__(self): ...
+    def __next__(self): ...
+    def next(self): ...
+    def read(self, size: int = ...) -> bytes: ...
+    def read1(self, size: int = ...) -> bytes: ...
+    def readinto(self, b) -> int: ...
+    def readinto1(self, b) -> int: ...
+
+class ZstdCompressionWriter(BinaryIO):
+    def __enter__(self) -> "ZstdCompressionWriter": ...
+    def __exit__(self, exc_type, exc_value, exc_tb): ...
+    def memory_size(self) -> int: ...
+    def fileno(self) -> int: ...
+    def close(self): ...
+    @property
+    def closed(self) -> bool: ...
+    def isatty(self) -> bool: ...
+    def readable(self) -> bool: ...
+    def readline(self, size: int = ...) -> bytes: ...
+    def readlines(self, hint: int = ...) -> List[bytes]: ...
+    def seek(self, offset: int, whence: int = ...): ...
+    def seekable(self) -> bool: ...
+    def truncate(self, size: int = ...): ...
+    def writable(self) -> bool: ...
+    def writelines(self, lines: Iterable[bytes]): ...
+    def read(self, size: int = ...) -> bytes: ...
+    def readall(self) -> bytes: ...
+    def readinto(self, b): ...
+    def write(self, data: ByteString) -> int: ...
+    def flush(self, flush_mode: int = ...) -> int: ...
+    def tell(self) -> int: ...
+
+class ZstdCompressor(object):
+    def __init__(
+        self,
+        level: int = ...,
+        dict_data: Optional[ZstdCompressionDict] = ...,
+        compression_params: Optional[ZstdCompressionParameters] = ...,
+        write_checksum: Optional[bool] = ...,
+        write_content_size: Optional[bool] = ...,
+        write_dict_id: Optional[bool] = ...,
+        threads: int = ...,
+    ): ...
+    def memory_size(self) -> int: ...
+    def compress(self, data: ByteString) -> bytes: ...
+    def compressobj(self, size: int = ...) -> ZstdCompressionObj: ...
+    def chunker(
+        self, size: int = ..., chunk_size: int = ...
+    ) -> ZstdCompressionChunker: ...
+    def copy_stream(
+        self,
+        ifh: IO[bytes],
+        ofh: IO[bytes],
+        size: int = ...,
+        read_size: int = ...,
+        write_size: int = ...,
+    ) -> Tuple[int, int]: ...
+    def stream_reader(
+        self,
+        source: Union[IO[bytes], ByteString],
+        size: int = ...,
+        read_size: int = ...,
+        *,
+        closefd: bool = ...,
+    ) -> ZstdCompressionReader: ...
+    def stream_writer(
+        self,
+        writer: IO[bytes],
+        size: int = ...,
+        write_size: int = ...,
+        write_return_read: bool = ...,
+        *,
+        closefd: bool = ...,
+    ) -> ZstdCompressionWriter: ...
+    def read_to_iter(
+        self,
+        reader: Union[IO[bytes], ByteString],
+        size: int = ...,
+        read_size: int = ...,
+        write_size: int = ...,
+    ) -> Generator[bytes, None, None]: ...
+    def frame_progression(self) -> Tuple[int, int, int]: ...
+    def multi_compress_to_buffer(
+        self,
+        data: Union[
+            BufferWithSegments,
+            BufferWithSegmentsCollection,
+            List[ByteString],
+        ],
+        threads: int = ...,
+    ) -> BufferWithSegmentsCollection: ...
+
+class ZstdDecompressionObj(object):
+    def decompress(self, data: ByteString) -> bytes: ...
+    def flush(self, length: int = ...) -> bytes: ...
+    @property
+    def unused_data(self) -> bytes: ...
+    @property
+    def unconsumed_tail(self) -> bytes: ...
+    @property
+    def eof(self) -> bool: ...
+
+class ZstdDecompressionReader(BinaryIO):
+    def __enter__(self) -> "ZstdDecompressionReader": ...
+    def __exit__(self, exc_type, exc_value, exc_tb): ...
+    def readable(self) -> bool: ...
+    def writable(self) -> bool: ...
+    def seekable(self) -> bool: ...
+    def readline(self, size: int = ...): ...
+    def readlines(self, hint: int = ...): ...
+    def write(self, data: ByteString): ...
+    def writelines(self, lines: Iterable[bytes]): ...
+    def isatty(self) -> bool: ...
+    def flush(self): ...
+    def close(self): ...
+    @property
+    def closed(self) -> bool: ...
+    def tell(self) -> int: ...
+    def readall(self) -> bytes: ...
+    def __iter__(self): ...
+    def __next__(self): ...
+    def next(self): ...
+    def read(self, size: int = ...) -> bytes: ...
+    def readinto(self, b) -> int: ...
+    def read1(self, size: int = ...) -> bytes: ...
+    def readinto1(self, b) -> int: ...
+    def seek(self, pos: int, whence: int = ...) -> int: ...
+
+class ZstdDecompressionWriter(BinaryIO):
+    def __enter__(self) -> "ZstdDecompressionWriter": ...
+    def __exit__(self, exc_type, exc_value, exc_tb): ...
+    def memory_size(self) -> int: ...
+    def close(self): ...
+    @property
+    def closed(self) -> bool: ...
+    def fileno(self) -> int: ...
+    def flush(self): ...
+    def isatty(self) -> bool: ...
+    def readable(self) -> bool: ...
+    def readline(self, size: int = ...): ...
+    def readlines(self, hint: int = ...): ...
+    def seek(self, offset: int, whence: int = ...): ...
+    def seekable(self) -> bool: ...
+    def tell(self): ...
+    def truncate(self, size: int = ...): ...
+    def writable(self) -> bool: ...
+    def writelines(self, lines: Iterable[bytes]): ...
+    def read(self, size: int = ...): ...
+    def readall(self): ...
+    def readinto(self, b): ...
+    def write(self, data: ByteString) -> int: ...
+
+class ZstdDecompressor(object):
+    def __init__(
+        self,
+        dict_data: Optional[ZstdCompressionDict] = ...,
+        max_window_size: int = ...,
+        format: int = ...,
+    ): ...
+    def memory_size(self) -> int: ...
+    def decompress(
+        self,
+        data: ByteString,
+        max_output_size: int = ...,
+        read_across_frames: bool = ...,
+        allow_extra_data: bool = ...,
+    ) -> bytes: ...
+    def stream_reader(
+        self,
+        source: Union[IO[bytes], ByteString],
+        read_size: int = ...,
+        read_across_frames: bool = ...,
+        *,
+        closefd=False,
+    ) -> ZstdDecompressionReader: ...
+    def decompressobj(
+        self, write_size: int = ..., read_across_frames: bool = False
+    ) -> ZstdDecompressionObj: ...
+    def read_to_iter(
+        self,
+        reader: Union[IO[bytes], ByteString],
+        read_size: int = ...,
+        write_size: int = ...,
+        skip_bytes: int = ...,
+    ) -> Generator[bytes, None, None]: ...
+    def stream_writer(
+        self,
+        writer: IO[bytes],
+        write_size: int = ...,
+        write_return_read: bool = ...,
+        *,
+        closefd: bool = ...,
+    ) -> ZstdDecompressionWriter: ...
+    def copy_stream(
+        self,
+        ifh: IO[bytes],
+        ofh: IO[bytes],
+        read_size: int = ...,
+        write_size: int = ...,
+    ) -> Tuple[int, int]: ...
+    def decompress_content_dict_chain(
+        self, frames: list[ByteString]
+    ) -> bytes: ...
+    def multi_decompress_to_buffer(
+        self,
+        frames: Union[
+            BufferWithSegments,
+            BufferWithSegmentsCollection,
+            List[ByteString],
+        ],
+        decompressed_sizes: ByteString = ...,
+        threads: int = ...,
+    ) -> BufferWithSegmentsCollection: ...
+
+class FrameParameters(object):
+    content_size: int
+    window_size: int
+    dict_id: int
+    has_checksum: bool
+
+def estimate_decompression_context_size() -> int: ...
+def frame_content_size(data: ByteString) -> int: ...
+def frame_header_size(data: ByteString) -> int: ...
+def get_frame_parameters(
+    data: ByteString, format: Optional[int] = None
+) -> FrameParameters: ...
+def train_dictionary(
+    dict_size: int,
+    samples: list[ByteString],
+    k: int = ...,
+    d: int = ...,
+    f: int = ...,
+    split_point: float = ...,
+    accel: int = ...,
+    notifications: int = ...,
+    dict_id: int = ...,
+    level: int = ...,
+    steps: int = ...,
+    threads: int = ...,
+) -> ZstdCompressionDict: ...
+def open(
+    filename: Union[bytes, str, os.PathLike, BinaryIO],
+    mode: str = ...,
+    cctx: Optional[ZstdCompressor] = ...,
+    dctx: Optional[ZstdDecompressor] = ...,
+    encoding: Optional[str] = ...,
+    errors: Optional[str] = ...,
+    newline: Optional[str] = ...,
+    closefd: bool = ...,
+): ...
+def compress(data: ByteString, level: int = ...) -> bytes: ...
+def decompress(data: ByteString, max_output_size: int = ...) -> bytes: ...

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

@@ -0,0 +1,112 @@
+"""Yarida kesilen cevabi sonraki modele tasir (10 Ekim 2026).
+
+Olcum: Codex kapanir ya da kullanici cevabi durdurursa o ana kadar yazilan metin sohbet gecmisine girmiyor;
+sonraki tur (ayni ya da baska modelle) "onceki cevabi goremiyorum" diyor. Kopru akisi zaten goruyor:
+ISTEMCI baglantiyi kapattiginda (yanit bitmeden) o ana kadarki metni bellekte tutar ve ayni sohbetin
+sonraki isteginde, kullanicinin yeni mesajina kisa bir not olarak ekler. Bir kez kullanilir.
+
+Bilerek yapilmayanlar:
+- Ust kaynak kopmasinda (istemci hala bagli) kayit yok: Codex o istegi kendisi yeniden gonderir; not eklenirse
+  model bastan yazmak yerine ortadan devam eder ve cevabin basi kaybolur.
+- Yarim metin asistan mesaji olarak eklenmez: Claude "asistan mesajiyla biten istek"i reddeder ve abonelik
+  yolunda kimliksiz asistan ogesi risklidir. Kullanici mesajina eklenen not her saglayicida gecerlidir.
+- Diske yazilmaz; kopru yeniden baslarsa kayit gider.
+"""
+import json
+import threading
+import time
+
+OMUR_SN = 6 * 3600
+EN_COK_KAYIT = 50
+EN_COK_KARAKTER = 12_000       # nota konan yarim metnin ust siniri (basi ve sonu korunur)
+EN_AZ_KARAKTER = 40            # bundan kisa yarim metin tasinmaya degmez
+NOT_BASI = "[Köprü notu: bir önceki cevabın yarıda kesildi ve sohbet geçmişine kaydedilmedi."
+_KILIT = threading.Lock()
+_KAYIT = {}                    # sohbet anahtari -> {"zaman", "metin", "model"}
+
+
+class Izleyici:
+    """Akistan gecen parcalardan asistan metnini toplar; yanitin bitip bitmedigini izler."""
+
+    def __init__(self, anahtar, model):
+        self.anahtar, self.model = anahtar, model
+        self.buf = b""
+        self.parcalar = []
+        self.bitti = False
+
+    def feed(self, chunk):
+        self.buf += chunk
+        while b"\n\n" in self.buf:
+            blok, self.buf = self.buf.split(b"\n\n", 1)
+            if b"response.output_text.delta" in blok:
+                for satir in blok.split(b"\n"):
+                    if satir.startswith(b"data:"):
+                        try:
+                            d = json.loads(satir[5:])
+                        except ValueError:
+                            continue
+                        if d.get("type") == "response.output_text.delta" and isinstance(d.get("delta"), str):
+                            self.parcalar.append(d["delta"])
+            elif b"response.completed" in blok or b"response.failed" in blok or b"response.incomplete" in blok:
+                self.bitti = True
+
+    @property
+    def metin(self):
+        return "".join(self.parcalar)
+
+
+def kaydet(izleyici, simdi=None):
+    """Istemci kapatti ve yanit bitmemisti: yarim metni sakla. True: saklandi."""
+    metin = izleyici.metin.strip()
+    if not izleyici.anahtar or izleyici.bitti or len(metin) < EN_AZ_KARAKTER:
+        return False
+    simdi = time.time() if simdi is None else simdi
+    with _KILIT:
+        _KAYIT[izleyici.anahtar] = {"zaman": simdi, "metin": metin, "model": izleyici.model}
+        for eski in sorted(_KAYIT, key=lambda k: _KAYIT[k]["zaman"])[:max(0, len(_KAYIT) - EN_COK_KAYIT)]:
+            del _KAYIT[eski]
+    return True
+
+
+def _kisalt(metin):
+    if len(metin) <= EN_COK_KARAKTER:
+        return metin
+    bas, son = EN_COK_KARAKTER // 4, EN_COK_KARAKTER - EN_COK_KARAKTER // 4
+    return metin[:bas] + f"\n[... ortadan {len(metin) - bas - son} karakter çıkarıldı ...]\n" + metin[-son:]
+
+
+def uygula(req, anahtar, simdi=None):
+    """Ayni sohbetin sonraki isteginde yarim metni kullanicinin son mesajina not olarak ekler.
+    Donus: eklenen karakter sayisi (0: eklenmedi). Kayit yalniz basariyla eklenince ya da eskiyince silinir."""
+    if not anahtar:
+        return 0
+    simdi = time.time() if simdi is None else simdi
+    with _KILIT:
+        kayit = _KAYIT.get(anahtar)
+        if kayit and simdi - kayit["zaman"] > OMUR_SN:
+            del _KAYIT[anahtar]
+            kayit = None
+    girdi = req.get("input")
+    if not kayit or not isinstance(girdi, list) or not girdi:
+        return 0
+    son = girdi[-1]
+    if not (isinstance(son, dict) and son.get("type", "message") == "message" and son.get("role") == "user"):
+        return 0            # sikistirma istegi, arac sonucu turu vb.: yeni kullanici mesajini bekle
+    metin = kayit["metin"]
+    ham = json.dumps(girdi, ensure_ascii=False)
+    if json.dumps(metin[:200], ensure_ascii=False)[1:-1] in ham:
+        with _KILIT:        # Codex bu metni gecmise kendisi yazmis: ikinci kez eklenmez
+            _KAYIT.pop(anahtar, None)
+        return 0
+    notu = (f"{NOT_BASI} Kesilmeden önce yazdığın metin aşağıda. Kullanıcı devam etmeni isterse baştan yazma, "
+            f"kaldığın yerden sürdür.]\n<yarim_cevap model=\"{kayit['model']}\">\n{_kisalt(metin)}\n</yarim_cevap>")
+    icerik = son.get("content")
+    if isinstance(icerik, str):
+        son["content"] = [{"type": "input_text", "text": icerik}, {"type": "input_text", "text": notu}]
+    elif isinstance(icerik, list):
+        icerik.append({"type": "input_text", "text": notu})
+    else:
+        return 0
+    with _KILIT:
+        _KAYIT.pop(anahtar, None)
+    return len(notu)

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

@@ -0,0 +1,287 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  addCodexLinkLine,
+  CODEX_LINK_LINE,
+  CODEX_LINK_RUN_COMMAND_MAX,
+  codexAutostartPlan,
+  codexBridgeArgs,
+  codexBridgeCommandLine,
+  codexBridgeConfig,
+  codexBridgeLauncherSource,
+  inspectCodexConfig,
+  parseCodexLinkSettings,
+  removeCodexLinkLine,
+  serializeCodexLinkSettings
+} from './codex-link-config'
+
+const FOREIGN = 'openai_base_url = "http://127.0.0.1:8799/backend-api/codex"'
+
+// Add then remove must hand the user's file back exactly as it was.
+function expectRoundTrip(original: string) {
+  const added = addCodexLinkLine(original)
+
+  expect(added.changed).toBe(true)
+  expect(added.owner).toBe('ours')
+  expect(inspectCodexConfig(added.text)).toBe('ours')
+
+  const removed = removeCodexLinkLine(added.text)
+
+  expect(removed.changed).toBe(true)
+  expect(removed.text).toBe(original)
+
+  return added.text
+}
+
+describe('the contract line', () => {
+  it('is the exact text Codex and the bridge agree on', () => {
+    expect(CODEX_LINK_LINE).toBe(
+      'openai_base_url = "http://127.0.0.1:8795/backend-api/codex"  # AITURK IDE Codex Baglama'
+    )
+  })
+})
+
+describe('addCodexLinkLine', () => {
+  it('writes the line into an empty file', () => {
+    expect(expectRoundTrip('')).toBe(`${CODEX_LINK_LINE}\n`)
+  })
+
+  it('puts the line before the first table when the file only has tables', () => {
+    const original = '[projects."C:\\\\work"]\ntrust_level = "trusted"\n\n[mcp_servers.x]\ncommand = "node"\n'
+    const text = expectRoundTrip(original)
+
+    expect(text.indexOf(CODEX_LINK_LINE)).toBeLessThan(text.indexOf('[projects.'))
+    expect(text.endsWith(original)).toBe(true)
+  })
+
+  it('keeps existing top-level keys and tables intact', () => {
+    const original = '# my config\nmodel = "gpt-6"\napproval_policy = "never"\n\n[features]\nweb = true\n'
+    const text = expectRoundTrip(original)
+
+    expect(text.indexOf(CODEX_LINK_LINE)).toBeLessThan(text.indexOf('[features]'))
+    expect(text).toContain('model = "gpt-6"\napproval_policy = "never"\n\n[features]\nweb = true\n')
+  })
+
+  it('preserves a CRLF file and writes its own line with CRLF', () => {
+    const original = 'model = "gpt-6"\r\n\r\n[features]\r\nweb = true\r\n'
+    const text = expectRoundTrip(original)
+
+    expect(text).toBe(`${CODEX_LINK_LINE}\r\n${original}`)
+    expect(text.replace(/\r\n/g, '')).not.toMatch(/[\r\n]/)
+  })
+
+  it('keeps a byte-order mark at the very start', () => {
+    const text = expectRoundTrip('\uFEFFmodel = "gpt-6"\n')
+
+    expect(text.startsWith(`\uFEFF${CODEX_LINK_LINE}\n`)).toBe(true)
+  })
+
+  it('keeps a file without a trailing newline exactly as it was', () => {
+    expectRoundTrip('model = "gpt-6"\n[features]\nweb = true')
+  })
+
+  it('is idempotent once our line is there', () => {
+    const once = addCodexLinkLine('model = "gpt-6"\n[features]\n').text
+    const twice = addCodexLinkLine(once)
+
+    expect(twice.changed).toBe(false)
+    expect(twice.owner).toBe('ours')
+    expect(twice.text).toBe(once)
+  })
+
+  it('refreshes a stale copy of our own line in place', () => {
+    const stale = 'model = "gpt-6"\nopenai_base_url = "http://127.0.0.1:1/x"  # AITURK IDE Codex Baglama\n[features]\n'
+    const edit = addCodexLinkLine(stale)
+
+    expect(edit.changed).toBe(true)
+    expect(edit.text).toBe(`model = "gpt-6"\n${CODEX_LINK_LINE}\n[features]\n`)
+  })
+
+  it('still owns its line after Codex rewrote the config and dropped the comment', () => {
+    const rewritten = 'openai_base_url = "http://127.0.0.1:8795/backend-api/codex"\nmodel = "x"\n'
+
+    expect(inspectCodexConfig(rewritten)).toBe('ours')
+    expect(removeCodexLinkLine(rewritten).text).toBe('model = "x"\n')
+    // Another local port is somebody else's bridge.
+    expect(inspectCodexConfig('openai_base_url = "http://127.0.0.1:8799/backend-api/codex"\n')).toBe('foreign')
+  })
+
+  it('does not touch a foreign openai_base_url and reports it', () => {
+    for (const original of [
+      `${FOREIGN}\n[features]\n`,
+      `model = "gpt-6"\r\n  ${FOREIGN} # my own bridge\r\n`,
+      '"openai_base_url" = "https://example.test/v1"\n',
+      "'openai_base_url'='https://example.test/v1'\n"
+    ]) {
+      const edit = addCodexLinkLine(original)
+
+      expect(edit).toEqual({ changed: false, owner: 'foreign', text: original })
+      expect(inspectCodexConfig(original)).toBe('foreign')
+    }
+  })
+
+  it('does not treat the same key under a table as top-level', () => {
+    const original = 'model = "gpt-6"\n\n[model_providers.mine]\nopenai_base_url = "https://example.test/v1"\n'
+
+    expect(inspectCodexConfig(original)).toBe('absent')
+
+    const text = expectRoundTrip(original)
+
+    expect(text.indexOf(CODEX_LINK_LINE)).toBeLessThan(text.indexOf('[model_providers.mine]'))
+    expect(text).toContain('[model_providers.mine]\nopenai_base_url = "https://example.test/v1"\n')
+  })
+
+  it('ignores the key inside a comment', () => {
+    const original = '# openai_base_url = "https://example.test/v1"\n  #openai_base_url = "x"\nmodel = "gpt-6"\n'
+
+    expect(inspectCodexConfig(original)).toBe('absent')
+    expectRoundTrip(original)
+  })
+
+  it('ignores look-alikes inside multi-line values', () => {
+    // Neither the "key" inside the string nor the "[table]" inside it is real,
+    // so the genuine foreign key after it must still be found.
+    const inString = 'notes = """\nopenai_base_url = "nope"\n[not.a.table]\n"""\nmodel = "gpt-6"\n'
+
+    expect(inspectCodexConfig(inString)).toBe('absent')
+    expect(inspectCodexConfig(`${inString}${FOREIGN}\n`)).toBe('foreign')
+
+    const inArray = 'notify = [\n  "a",\n  ["b"]\n]\n'
+
+    expect(inspectCodexConfig(`${inArray}${FOREIGN}\n`)).toBe('foreign')
+    expect(inspectCodexConfig(`literal = '''\n[x]\n'''\n${FOREIGN}\n`)).toBe('foreign')
+  })
+
+  it('is not fooled by a bracket or hash inside a quoted value', () => {
+    const original = `title = "a [b] # c"\n${FOREIGN}\n`
+
+    expect(inspectCodexConfig(original)).toBe('foreign')
+  })
+})
+
+describe('removeCodexLinkLine', () => {
+  it('removes only our line, wherever the user moved it', () => {
+    const text = `model = "gpt-6"\r\n${CODEX_LINK_LINE}\r\napproval_policy = "never"\r\n[features]\r\n`
+    const edit = removeCodexLinkLine(text)
+
+    expect(edit).toEqual({
+      changed: true,
+      owner: 'absent',
+      text: 'model = "gpt-6"\r\napproval_policy = "never"\r\n[features]\r\n'
+    })
+  })
+
+  it('leaves a file without our line untouched', () => {
+    for (const original of ['', 'model = "gpt-6"\n', `${FOREIGN}\n[features]\n`]) {
+      expect(removeCodexLinkLine(original).changed).toBe(false)
+      expect(removeCodexLinkLine(original).text).toBe(original)
+    }
+  })
+
+  it('never removes a foreign line', () => {
+    expect(removeCodexLinkLine(`${FOREIGN}\n`)).toEqual({ changed: false, owner: 'foreign', text: `${FOREIGN}\n` })
+  })
+
+  it('leaves our marker alone when it sits under a table', () => {
+    const original = `[model_providers.mine]\n${CODEX_LINK_LINE}\n`
+
+    expect(removeCodexLinkLine(original)).toEqual({ changed: false, owner: 'absent', text: original })
+  })
+})
+
+describe('preference file', () => {
+  it('is on by default when the file is missing or malformed', () => {
+    for (const raw of [null, undefined, '', '{', 'null', '[]', '"off"', '{"kapsam":"ide"}', '{"enabled":"false"}']) {
+      expect(parseCodexLinkSettings(raw).enabled).toBe(true)
+    }
+  })
+
+  it('is off only when explicitly disabled', () => {
+    expect(parseCodexLinkSettings('{"enabled": false, "kapsam": "ide"}').enabled).toBe(false)
+    expect(parseCodexLinkSettings('{"enabled": true}').enabled).toBe(true)
+  })
+
+  it('writes the contract shape and keeps unknown fields', () => {
+    expect(JSON.parse(serializeCodexLinkSettings({}, false))).toEqual({ enabled: false, kapsam: 'ide' })
+
+    const { stored } = parseCodexLinkSettings('{"enabled": false, "kapsam": "hepsi", "gelecek": {"a": 1}}')
+
+    expect(JSON.parse(serializeCodexLinkSettings(stored, true))).toEqual({
+      enabled: true,
+      gelecek: { a: 1 },
+      kapsam: 'hepsi'
+    })
+  })
+})
+
+describe('bridge configuration and command', () => {
+  const launch = {
+    bridgeHome: 'C:\\Users\\a b\\AppData\\Local\\TurkServis\\AITURK-IDE\\codex-bridge',
+    bridgeScript: 'C:\\Program Files\\AITURK IDE\\resources\\codex-bridge\\bridge.py',
+    hermesHome: 'C:\\Users\\a b\\AppData\\Local\\TurkServis\\AITURK-IDE\\agent'
+  }
+
+  const python = `${launch.hermesHome}\\hermes-agent\\venv\\Scripts\\pythonw.exe`
+
+  it('writes the agreed bridge.json', () => {
+    expect(codexBridgeConfig()).toEqual({
+      port: 8795,
+      chatgpt_backend: 'https://chatgpt.com',
+      routes: {},
+      nine_router_catalog: { enabled: false },
+      pano_kanca_user: false,
+      ozet_kopru: { enabled: true, kapsam: 'hepsi', openai_modeli: 'gpt-6-luna', dongu_siniri: 8, dongu_art_arda: 3 }
+    })
+  })
+
+  it('passes the same arguments to the spawn and the login item', () => {
+    expect(codexBridgeArgs(launch)).toEqual([
+      launch.bridgeScript,
+      '--home',
+      launch.bridgeHome,
+      '--hermes-home',
+      launch.hermesHome
+    ])
+    expect(codexBridgeCommandLine(python, launch)).toBe(
+      `"${python}" "${launch.bridgeScript}" --home "${launch.bridgeHome}" --hermes-home "${launch.hermesHome}"`
+    )
+  })
+
+  it('drops a trailing separator that would escape the closing quote', () => {
+    expect(
+      codexBridgeCommandLine('C:\\py\\pythonw.exe', {
+        bridgeHome: 'C:\\d\\',
+        bridgeScript: 'C:\\b.py',
+        hermesHome: 'C:\\h\\'
+      })
+    ).toBe('"C:\\py\\pythonw.exe" "C:\\b.py" --home "C:\\d" --hermes-home "C:\\h"')
+  })
+
+  it('uses the direct command for the login item when it fits a Run value', () => {
+    const short = { bridgeHome: 'C:\\d', bridgeScript: 'C:\\b\\bridge.py', hermesHome: 'C:\\h' }
+
+    expect(codexAutostartPlan('C:\\py\\pythonw.exe', short, 'C:\\d\\baslat.pyw')).toEqual({
+      command: '"C:\\py\\pythonw.exe" "C:\\b\\bridge.py" --home "C:\\d" --hermes-home "C:\\h"',
+      launcher: null
+    })
+  })
+
+  it('falls back to a launcher when the direct command is too long for a Run value', () => {
+    expect(codexBridgeCommandLine(python, launch).length).toBeGreaterThan(CODEX_LINK_RUN_COMMAND_MAX)
+
+    const launcherPath = `${launch.bridgeHome}\\baslat.pyw`
+    const plan = codexAutostartPlan(python, launch, launcherPath)
+
+    expect(plan?.command).toBe(`"${python}" "${launcherPath}"`)
+    expect(plan?.command.length).toBeLessThanOrEqual(CODEX_LINK_RUN_COMMAND_MAX)
+    expect(plan?.launcher).toEqual({ path: launcherPath, source: codexBridgeLauncherSource(launch) })
+    // The launcher carries the very same argv as the direct command.
+    expect(plan?.launcher?.source).toContain(`ARGV = ${JSON.stringify(codexBridgeArgs(launch))}`)
+  })
+
+  it('registers nothing when not even the launcher command fits', () => {
+    const deep = `C:\\${'x'.repeat(300)}`
+
+    expect(codexAutostartPlan(`${deep}\\pythonw.exe`, launch, `${deep}\\baslat.pyw`)).toBeNull()
+  })
+})

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

@@ -0,0 +1,429 @@
+/**
+ * Codex Link ("Codex Bağlama") — the pure half.
+ *
+ * AITURK IDE ships a small local Python bridge that lets the OpenAI Codex
+ * installed on this machine use the IDE's models and combos. Turning the
+ * feature on means editing a file the IDE does not own (Codex's `config.toml`)
+ * and registering a login item, so every text transformation lives here as a
+ * dependency-free, byte-preserving function that can be proven without
+ * Electron, a filesystem, or a registry. `codex-link.ts` owns the decisions and
+ * the side effects.
+ *
+ * Invariants:
+ *  - Only the line carrying OUR trailing comment is ever written or removed.
+ *  - An `openai_base_url` that is not ours means someone else's bridge is in
+ *    charge: report `foreign` and change nothing.
+ *  - Everything else in the file — including its line endings and BOM — comes
+ *    back byte for byte.
+ */
+
+export const CODEX_LINK_PORT = 8795
+export const CODEX_LINK_ORIGIN = `http://127.0.0.1:${CODEX_LINK_PORT}`
+export const CODEX_LINK_STATUS_URL = `${CODEX_LINK_ORIGIN}/aiturk/codex-baglama/status`
+export const CODEX_LINK_STOP_URL = `${CODEX_LINK_ORIGIN}/aiturk/codex-baglama/stop`
+export const CODEX_LINK_REFRESH_URL = `${CODEX_LINK_ORIGIN}/aiturk/codex-baglama/refresh`
+
+/** The trailing comment that marks the line as ours. */
+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 = '8'
+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'
+export const CODEX_LINK_RUN_VALUE = 'AITURK-IDE-Codex-Baglama'
+export const CODEX_LINK_LAUNCHER_NAME = 'baslat.pyw'
+
+// Windows documents Run-key command lines as "no longer than 260 characters".
+// A longer value is not reliably started at sign-in, so the direct command is
+// only used when it fits (see autostartPlan).
+export const CODEX_LINK_RUN_COMMAND_MAX = 260
+
+/** Who owns the top-level `openai_base_url` in a Codex config. */
+export type CodexConfigOwner = 'absent' | 'foreign' | 'ours'
+
+interface Line {
+  eol: string
+  text: string
+}
+
+const BOM = '\uFEFF'
+const KEY_PATTERN = /^[ \t]*(?:openai_base_url|"openai_base_url"|'openai_base_url')[ \t]*=/
+
+// Split into lines WITHOUT losing anything: joining `text + eol` of every entry
+// reproduces the input exactly, whatever mix of \n, \r\n and \r it used.
+function splitLines(source: string): Line[] {
+  const lines: Line[] = []
+  let start = 0
+
+  while (start < source.length) {
+    let end = start
+
+    while (end < source.length && source[end] !== '\n' && source[end] !== '\r') {
+      end += 1
+    }
+
+    let eol = ''
+
+    if (end < source.length) {
+      eol = source[end] === '\r' && source[end + 1] === '\n' ? '\r\n' : source[end]
+    }
+
+    lines.push({ eol, text: source.slice(start, end) })
+    start = end + eol.length
+  }
+
+  return lines
+}
+
+function joinLines(lines: Line[]): string {
+  return lines.map(line => line.text + line.eol).join('')
+}
+
+function splitBom(source: string): { body: string; bom: string } {
+  return source.startsWith(BOM) ? { body: source.slice(1), bom: BOM } : { body: source, bom: '' }
+}
+
+type MultilineQuote = "'''" | '"""' | null
+
+interface ValueState {
+  depth: number
+  multiline: MultilineQuote
+}
+
+// Index just past the `=` of a `key = value` line, or the line length when the
+// line holds no value (blank, comment, malformed). Quoted keys may contain `=`.
+function valueStart(text: string): number {
+  let pos = 0
+
+  while (pos < text.length) {
+    const char = text[pos]
+
+    if (char === '#') {
+      return text.length
+    }
+
+    if (char === '=') {
+      return pos + 1
+    }
+
+    if (char === '"' || char === "'") {
+      pos += 1
+
+      while (pos < text.length && text[pos] !== char) {
+        pos += char === '"' && text[pos] === '\\' ? 2 : 1
+      }
+    }
+
+    pos += 1
+  }
+
+  return text.length
+}
+
+// Walk a value just far enough to know whether the NEXT line is still inside it
+// (multi-line string or array). That is the only TOML the top-level scan needs:
+// without it, text inside a multi-line value could pass for a key or a table
+// header.
+function scanValue(text: string, from: number, state: ValueState): ValueState {
+  let { depth, multiline } = state
+  let pos = from
+
+  while (pos < text.length) {
+    if (multiline) {
+      if (multiline === '"""' && text[pos] === '\\') {
+        pos += 2
+
+        continue
+      }
+
+      if (text.startsWith(multiline, pos)) {
+        pos += 3
+
+        // Up to two quotes may sit directly before the closing delimiter.
+        while (text[pos] === multiline[0]) {
+          pos += 1
+        }
+
+        multiline = null
+
+        continue
+      }
+
+      pos += 1
+
+      continue
+    }
+
+    const char = text[pos]
+
+    if (char === '#') {
+      break
+    }
+
+    if (text.startsWith('"""', pos) || text.startsWith("'''", pos)) {
+      multiline = text.slice(pos, pos + 3) as MultilineQuote
+      pos += 3
+
+      continue
+    }
+
+    if (char === '"' || char === "'") {
+      pos += 1
+
+      while (pos < text.length && text[pos] !== char) {
+        pos += char === '"' && text[pos] === '\\' ? 2 : 1
+      }
+
+      pos += 1
+
+      continue
+    }
+
+    if (char === '[' || char === '{') {
+      depth += 1
+    } else if (char === ']' || char === '}') {
+      depth = Math.max(0, depth - 1)
+    }
+
+    pos += 1
+  }
+
+  return { depth, multiline }
+}
+
+// Indices of the top-level `openai_base_url` lines: those before the first
+// `[table]` header, outside comments and multi-line values.
+function topLevelEntries(lines: Line[]): { index: number; ours: boolean }[] {
+  const entries: { index: number; ours: boolean }[] = []
+  let state: ValueState = { depth: 0, multiline: null }
+
+  for (let index = 0; index < lines.length; index += 1) {
+    const { text } = lines[index]
+    let from = 0
+
+    if (!state.multiline && state.depth === 0) {
+      if (text.trimStart().startsWith('[')) {
+        break
+      }
+
+      if (KEY_PATTERN.test(text)) {
+        // Ours by marker or by value: Codex may rewrite its config and drop the comment.
+        entries.push({
+          index,
+          ours: text.includes(CODEX_LINK_MARKER) || text.includes(`"${CODEX_LINK_ORIGIN}/backend-api/codex"`)
+        })
+      }
+
+      from = valueStart(text)
+    }
+
+    state = scanValue(text, from, state)
+  }
+
+  return entries
+}
+
+function ownerOf(entries: { ours: boolean }[]): CodexConfigOwner {
+  if (entries.some(entry => !entry.ours)) {
+    return 'foreign'
+  }
+
+  return entries.length > 0 ? 'ours' : 'absent'
+}
+
+/** Who owns the top-level `openai_base_url` of this config text. */
+export function inspectCodexConfig(source: string): CodexConfigOwner {
+  return ownerOf(topLevelEntries(splitLines(splitBom(source).body)))
+}
+
+export interface CodexConfigEdit {
+  changed: boolean
+  owner: CodexConfigOwner
+  text: string
+}
+
+/**
+ * Point Codex at the bridge. Idempotent; a foreign `openai_base_url` leaves the
+ * text untouched and reports `foreign`.
+ *
+ * The line goes on the very first line: top-level keys must precede the first
+ * table header, and the top of the file is the one position that is always
+ * top-level without having to understand the values below it.
+ */
+export function addCodexLinkLine(source: string): CodexConfigEdit {
+  const { body, bom } = splitBom(source)
+  const lines = splitLines(body)
+  const entries = topLevelEntries(lines)
+  const owner = ownerOf(entries)
+
+  if (owner === 'foreign') {
+    return { changed: false, owner, text: source }
+  }
+
+  if (owner === 'ours') {
+    const [first, ...duplicates] = entries
+
+    if (duplicates.length === 0 && lines[first.index].text === CODEX_LINK_LINE) {
+      return { changed: false, owner, text: source }
+    }
+
+    // A stale copy of our line (older address) or an accidental duplicate:
+    // normalize to exactly one current line, in place.
+    const drop = new Set(duplicates.map(entry => entry.index))
+    lines[first.index] = { ...lines[first.index], text: CODEX_LINK_LINE }
+
+    return { changed: true, owner, text: bom + joinLines(lines.filter((_line, index) => !drop.has(index))) }
+  }
+
+  const eol = body.includes('\r\n') ? '\r\n' : '\n'
+
+  return { changed: true, owner: 'ours', text: `${bom}${CODEX_LINK_LINE}${eol}${body}` }
+}
+
+/** Remove our line (and only ours). A foreign key is left exactly as it was. */
+export function removeCodexLinkLine(source: string): CodexConfigEdit {
+  const { body, bom } = splitBom(source)
+  const lines = splitLines(body)
+  const entries = topLevelEntries(lines)
+  const drop = new Set(entries.filter(entry => entry.ours).map(entry => entry.index))
+  const remaining = ownerOf(entries.filter(entry => !entry.ours))
+
+  if (drop.size === 0) {
+    return { changed: false, owner: remaining, text: source }
+  }
+
+  return { changed: true, owner: remaining, text: bom + joinLines(lines.filter((_line, index) => !drop.has(index))) }
+}
+
+// ── Preference file ─────────────────────────────────────────────────────────
+
+export interface CodexLinkSettings {
+  enabled: boolean
+  /** Every field of the stored object, so a rewrite keeps what it did not set. */
+  stored: Record<string, unknown>
+}
+
+/** 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: {} }
+  }
+
+  try {
+    const parsed = JSON.parse(raw)
+
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+      return { enabled: true, stored: {} }
+    }
+
+    return { enabled: parsed.enabled !== false, stored: parsed as Record<string, unknown> }
+  } catch {
+    return { enabled: true, stored: {} }
+  }
+}
+
+export function serializeCodexLinkSettings(stored: Record<string, unknown>, enabled: boolean): string {
+  const kapsam = typeof stored.kapsam === 'string' && stored.kapsam ? stored.kapsam : 'ide'
+
+  return `${JSON.stringify({ ...stored, enabled, kapsam }, null, 2)}\n`
+}
+
+// ── Bridge configuration ────────────────────────────────────────────────────
+
+/** `bridge.json`, rewritten on every apply. */
+export function codexBridgeConfig() {
+  return {
+    port: CODEX_LINK_PORT,
+    chatgpt_backend: 'https://chatgpt.com',
+    routes: {},
+    nine_router_catalog: { enabled: false },
+    pano_kanca_user: false,
+    ozet_kopru: { enabled: true, kapsam: 'hepsi', openai_modeli: 'gpt-6-luna', dongu_siniri: 8, dongu_art_arda: 3 }
+  }
+}
+
+export function serializeCodexBridgeConfig(): string {
+  return `${JSON.stringify(codexBridgeConfig(), null, 2)}\n`
+}
+
+// ── Bridge command line ─────────────────────────────────────────────────────
+
+export interface CodexBridgeLaunch {
+  bridgeHome: string
+  bridgeScript: string
+  hermesHome: string
+}
+
+/** Arguments after the interpreter — identical for the spawn and the login item. */
+export function codexBridgeArgs({ bridgeHome, bridgeScript, hermesHome }: CodexBridgeLaunch): string[] {
+  return [bridgeScript, '--home', bridgeHome, '--hermes-home', hermesHome]
+}
+
+// A trailing backslash would escape the closing quote (`"C:\dir\"`).
+function quoted(value: string): string {
+  return `"${value.replace(/[\\/]+$/, '')}"`
+}
+
+/** `"<pythonw>" "<bridge.py>" --home "<data>" --hermes-home "<agent>"` */
+export function codexBridgeCommandLine(python: string, launch: CodexBridgeLaunch): string {
+  const [script, homeFlag, home, hermesFlag, hermes] = codexBridgeArgs(launch)
+
+  return `${quoted(python)} ${quoted(script)} ${homeFlag} ${quoted(home)} ${hermesFlag} ${quoted(hermes)}`
+}
+
+/**
+ * A tiny windowless launcher for the login item, used when the direct command
+ * would not fit a Run value. It runs the bridge exactly as the direct command
+ * would: same script, same arguments, the script's folder first on sys.path so
+ * its helper modules import.
+ */
+export function codexBridgeLauncherSource(launch: CodexBridgeLaunch): string {
+  const argv = JSON.stringify(codexBridgeArgs(launch))
+
+  return [
+    '# Written by AITURK IDE (Settings > Codex Baglama). Regenerated on every sync; do not edit.',
+    'import os',
+    'import runpy',
+    'import sys',
+    '',
+    `ARGV = ${argv}`,
+    '',
+    'sys.argv = list(ARGV)',
+    'sys.path.insert(0, os.path.dirname(ARGV[0]))',
+    "runpy.run_path(ARGV[0], run_name='__main__')",
+    ''
+  ].join('\n')
+}
+
+export interface CodexAutostartPlan {
+  command: string
+  /** Launcher file to write first; null when the direct command is used. */
+  launcher: { path: string; source: string } | null
+}
+
+/**
+ * The login-item command. Prefer the direct bridge command; fall back to the
+ * launcher when that exceeds the Run-value limit. Returns null when not even
+ * the launcher form fits (nothing is registered rather than something that
+ * silently never starts).
+ */
+export function codexAutostartPlan(
+  python: string,
+  launch: CodexBridgeLaunch,
+  launcherPath: string
+): CodexAutostartPlan | null {
+  const direct = codexBridgeCommandLine(python, launch)
+
+  if (direct.length <= CODEX_LINK_RUN_COMMAND_MAX) {
+    return { command: direct, launcher: null }
+  }
+
+  const viaLauncher = `${quoted(python)} ${quoted(launcherPath)}`
+
+  if (viaLauncher.length > CODEX_LINK_RUN_COMMAND_MAX) {
+    return null
+  }
+
+  return { command: viaLauncher, launcher: { path: launcherPath, source: codexBridgeLauncherSource(launch) } }
+}

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

@@ -0,0 +1,39 @@
+/**
+ * Codex Link ("Codex Bağlama") — the shape that crosses the IPC bridge.
+ *
+ * Types only, so the renderer can import them without pulling main-process
+ * code into its program. See codex-link.ts for what the fields mean in action.
+ */
+
+export type CodexLinkIdeState = 'anahtar-yok' | 'kapali' | 'tamam'
+
+/** Stable codes; the renderer owns the wording. Detail goes to the desktop log. */
+export type CodexLinkError =
+  | 'autostart-failed'
+  | 'bridge-config-failed'
+  | 'bridge-missing'
+  | 'bridge-start-failed'
+  | 'config-write-failed'
+  | 'settings-write-failed'
+
+export interface CodexLinkStatus {
+  enabled: boolean
+  /** Codex's `config.toml` exists on this machine. */
+  codexFound: boolean
+  /** The IDE's own Python environment exists (first-run setup finished). */
+  venvReady: boolean
+  /** Codex already uses another bridge; nothing of its setup is touched. */
+  foreign: boolean
+  bridgeRunning: boolean
+  /** From the bridge's status endpoint; null while it is not answering. */
+  ideDurum: CodexLinkIdeState | null
+  ideModel: null | number
+  ozet: boolean | null
+  lastError: CodexLinkError | null
+}
+
+export interface CodexLinkPatch {
+  enabled?: boolean
+  /** "Sync now": re-run the apply without changing the preference. */
+  sync?: boolean
+}

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

@@ -0,0 +1,401 @@
+import { describe, expect, it } from 'vitest'
+
+import { CODEX_BRIDGE_START_BUDGET_MS, type CodexLinkDeps, type CodexLinkPaths, createCodexLink } from './codex-link'
+import {
+  CODEX_BRIDGE_VERSION,
+  CODEX_LINK_LINE,
+  CODEX_LINK_REFRESH_URL,
+  CODEX_LINK_STATUS_URL,
+  CODEX_LINK_STOP_URL,
+  codexBridgeArgs,
+  codexBridgeConfig
+} from './codex-link-config'
+
+const PATHS: CodexLinkPaths = {
+  settingsFile: 'D:\\ide\\codex-baglama.json',
+  bridgeHome: 'D:\\ide\\codex-bridge',
+  hermesHome: 'D:\\ide\\agent',
+  bridgeScript: 'D:\\app\\codex-bridge\\bridge.py',
+  pythonw: 'D:\\ide\\agent\\venv\\Scripts\\pythonw.exe',
+  python: 'D:\\ide\\agent\\venv\\Scripts\\python.exe',
+  codexConfig: 'D:\\home\\.codex\\config.toml'
+}
+
+const BRIDGE_JSON = `${PATHS.bridgeHome}\\bridge.json`
+const STATUS_OK = { ok: true, surum: CODEX_BRIDGE_VERSION, ide_durum: 'tamam', ide_model: 7, ozet: true }
+const USER_CONFIG = 'model = "gpt-6"\r\n\r\n[features]\r\nweb = true\r\n'
+
+interface World {
+  /** What the machine looks like; mutated by the fake effects. */
+  files: Map<string, string>
+  /** Is something answering on the bridge port? */
+  listening: boolean
+  /** Version the listening bridge reports before any spawn; a spawn brings the current one. */
+  staleVersion: null | string
+  /** Does a spawn bring the bridge up? `false` = it never answers. */
+  spawnWorks: boolean
+  /** Spawned bridge only starts answering after this many status probes. */
+  probesUntilUp: number
+  autostart: null | string
+  regFails: boolean
+  /** Every observable effect, in order. */
+  events: string[]
+  clock: number
+}
+
+function createWorld(patch: Partial<World> & { files?: Map<string, string> } = {}) {
+  const world: World = {
+    autostart: null,
+    clock: 0,
+    events: [],
+    files: new Map([
+      [PATHS.codexConfig, USER_CONFIG],
+      [PATHS.bridgeScript, '# bridge'],
+      [PATHS.pythonw, ''],
+      [PATHS.python, '']
+    ]),
+    listening: false,
+    staleVersion: null,
+    probesUntilUp: 0,
+    regFails: false,
+    spawnWorks: true,
+    ...patch
+  }
+
+  let spawned = false
+  let probesSinceSpawn = 0
+
+  const deps: CodexLinkDeps = {
+    paths: PATHS,
+    exists: file => world.files.has(file),
+    readText: file => world.files.get(file) ?? null,
+    writeTextAtomic: (file, text) => {
+      world.events.push(`write ${file}`)
+      world.files.set(file, text)
+    },
+    spawnBridge: (command, args, env) => {
+      world.events.push(`spawn ${command} ${JSON.stringify(args)} ${JSON.stringify(env)}`)
+      spawned = true
+      probesSinceSpawn = 0
+      world.staleVersion = null
+    },
+    request: async (method, url) => {
+      if (method === 'GET' && url === CODEX_LINK_STATUS_URL) {
+        if (spawned && world.spawnWorks && !world.listening) {
+          probesSinceSpawn += 1
+
+          if (probesSinceSpawn > world.probesUntilUp) {
+            world.listening = true
+          }
+        }
+
+        if (world.listening) {
+          world.events.push('status ok')
+
+          return world.staleVersion ? { ...STATUS_OK, surum: world.staleVersion } : STATUS_OK
+        }
+
+        return null
+      }
+
+      if (method === 'POST' && url === CODEX_LINK_REFRESH_URL) {
+        world.events.push('refresh')
+
+        return world.listening ? STATUS_OK : null
+      }
+
+      if (method === 'POST' && url === CODEX_LINK_STOP_URL) {
+        world.events.push('stop')
+
+        if (!world.listening) {
+          return null
+        }
+
+        world.listening = false
+
+        return { ok: true }
+      }
+
+      throw new Error(`unexpected request ${method} ${url}`)
+    },
+    setAutostart: async command => {
+      world.events.push('autostart set')
+
+      if (world.regFails) {
+        throw new Error('reg add exited 1')
+      }
+
+      world.autostart = command
+    },
+    clearAutostart: async () => {
+      world.events.push('autostart clear')
+      world.autostart = null
+    },
+    sleep: async ms => {
+      world.clock += ms
+    },
+    now: () => world.clock,
+    log: () => undefined
+  }
+
+  return { link: createCodexLink(deps), world }
+}
+
+const writes = (world: World) => world.events.filter(event => event.startsWith('write '))
+const spawns = (world: World) => world.events.filter(event => event.startsWith('spawn '))
+// Effects that change the machine (a status probe does not).
+const effects = (world: World) => world.events.filter(event => event !== 'status ok')
+
+describe('applyCodexLink', () => {
+  it('touches nothing when Codex is not installed', async () => {
+    const { link, world } = createWorld()
+    world.files.delete(PATHS.codexConfig)
+
+    const status = await link.apply()
+
+    expect(status).toMatchObject({ enabled: true, codexFound: false, bridgeRunning: false, lastError: null })
+    expect(effects(world)).toEqual([])
+    expect(world.autostart).toBeNull()
+  })
+
+  it('touches nothing when Codex already uses another bridge', async () => {
+    const foreign = 'openai_base_url = "http://127.0.0.1:8799/backend-api/codex"\n[features]\n'
+    const { link, world } = createWorld({ listening: true })
+    world.files.set(PATHS.codexConfig, foreign)
+
+    const status = await link.apply({ sync: true })
+
+    expect(status).toMatchObject({ enabled: true, codexFound: true, foreign: true, bridgeRunning: true })
+    expect(effects(world)).toEqual([])
+    expect(world.files.get(PATHS.codexConfig)).toBe(foreign)
+  })
+
+  it('waits for the IDE setup: no venv, no changes', async () => {
+    const { link, world } = createWorld()
+    world.files.delete(PATHS.pythonw)
+    world.files.delete(PATHS.python)
+
+    const status = await link.apply()
+
+    expect(status).toMatchObject({ enabled: true, codexFound: true, venvReady: false, foreign: false })
+    expect(effects(world)).toEqual([])
+  })
+
+  it('brings everything up in the safe order', async () => {
+    const { link, world } = createWorld({ probesUntilUp: 2 })
+
+    const status = await link.apply()
+
+    expect(status).toEqual({
+      enabled: true,
+      codexFound: true,
+      venvReady: true,
+      foreign: false,
+      bridgeRunning: true,
+      ideDurum: 'tamam',
+      ideModel: 7,
+      ozet: true,
+      lastError: null
+    })
+
+    const env = { AITURK_CODEX_BRIDGE_HOME: PATHS.bridgeHome, HERMES_HOME: PATHS.hermesHome }
+
+    const args = codexBridgeArgs({
+      bridgeHome: PATHS.bridgeHome,
+      bridgeScript: PATHS.bridgeScript,
+      hermesHome: PATHS.hermesHome
+    })
+
+    // bridge.json → start → verified answer → config.toml → login item
+    expect(world.events).toEqual([
+      `write ${BRIDGE_JSON}`,
+      `spawn ${PATHS.pythonw} ${JSON.stringify(args)} ${JSON.stringify(env)}`,
+      'status ok',
+      `write ${PATHS.codexConfig}`,
+      'autostart set'
+    ])
+
+    expect(JSON.parse(world.files.get(BRIDGE_JSON) ?? '')).toEqual(codexBridgeConfig())
+    expect(world.files.get(PATHS.codexConfig)).toBe(`${CODEX_LINK_LINE}\r\n${USER_CONFIG}`)
+    expect(world.autostart).toBe(
+      `"${PATHS.pythonw}" "${PATHS.bridgeScript}" --home "${PATHS.bridgeHome}" --hermes-home "${PATHS.hermesHome}"`
+    )
+  })
+
+  it('never points Codex at a bridge that did not come up', async () => {
+    const { link, world } = createWorld({ spawnWorks: false })
+
+    const status = await link.apply()
+
+    expect(status).toMatchObject({ enabled: true, bridgeRunning: false, lastError: 'bridge-start-failed' })
+    expect(spawns(world)).toHaveLength(1)
+    expect(world.files.get(PATHS.codexConfig)).toBe(USER_CONFIG)
+    expect(world.autostart).toBeNull()
+    expect(writes(world)).toEqual([`write ${BRIDGE_JSON}`])
+    // The start poll is bounded by its one budget.
+    expect(world.clock).toBe(CODEX_BRIDGE_START_BUDGET_MS)
+  })
+
+  it('takes its own line back out when the bridge can no longer be started', async () => {
+    const { link, world } = createWorld({ spawnWorks: false })
+    world.files.set(PATHS.codexConfig, `${CODEX_LINK_LINE}\r\n${USER_CONFIG}`)
+
+    const status = await link.apply()
+
+    expect(status.lastError).toBe('bridge-start-failed')
+    expect(world.files.get(PATHS.codexConfig)).toBe(USER_CONFIG)
+  })
+
+  it('does not start a second bridge when one is already listening', async () => {
+    const { link, world } = createWorld({ listening: true })
+
+    await link.apply()
+    await link.apply({ sync: true })
+
+    expect(spawns(world)).toEqual([])
+    expect(world.files.get(PATHS.codexConfig)).toBe(`${CODEX_LINK_LINE}\r\n${USER_CONFIG}`)
+    // The config is written once; the login item is refreshed on every apply.
+    expect(writes(world).filter(event => event === `write ${PATHS.codexConfig}`)).toHaveLength(1)
+    expect(world.events.filter(event => event === 'autostart set')).toHaveLength(2)
+  })
+
+  it('replaces a bridge left running by an older IDE build', async () => {
+    const { link, world } = createWorld({ listening: true, staleVersion: '0' })
+
+    const status = await link.apply()
+
+    expect(world.events.indexOf('stop')).toBeGreaterThanOrEqual(0)
+    expect(spawns(world)).toHaveLength(1)
+    expect(world.events.indexOf('stop')).toBeLessThan(world.events.findIndex(event => event.startsWith('spawn')))
+    expect(status.bridgeRunning).toBe(true)
+    expect(world.files.get(PATHS.codexConfig)).toBe(`${CODEX_LINK_LINE}\r\n${USER_CONFIG}`)
+  })
+
+  it('asks a running bridge to re-read the IDE session on every apply', async () => {
+    const { link, world } = createWorld({ listening: true })
+
+    await link.apply({ sync: true })
+
+    expect(world.events).toContain('refresh')
+    expect(spawns(world)).toEqual([])
+  })
+
+  it('falls back to python.exe when pythonw.exe is missing', async () => {
+    const { link, world } = createWorld()
+    world.files.delete(PATHS.pythonw)
+
+    await link.apply()
+
+    expect(spawns(world)[0]).toContain(`spawn ${PATHS.python} `)
+    expect(world.autostart?.startsWith(`"${PATHS.python}" `)).toBe(true)
+  })
+
+  it('reports a missing bridge script instead of starting anything', async () => {
+    const { link, world } = createWorld()
+    world.files.delete(PATHS.bridgeScript)
+
+    const status = await link.apply()
+
+    expect(status.lastError).toBe('bridge-missing')
+    expect(effects(world)).toEqual([])
+  })
+
+  it('surfaces a registry failure but keeps the working link', async () => {
+    const { link, world } = createWorld({ listening: true, regFails: true })
+
+    const status = await link.apply()
+
+    expect(status).toMatchObject({ bridgeRunning: true, lastError: 'autostart-failed' })
+    expect(world.files.get(PATHS.codexConfig)).toBe(`${CODEX_LINK_LINE}\r\n${USER_CONFIG}`)
+  })
+
+  it('undoes everything when turned off', async () => {
+    const { link, world } = createWorld({ listening: true })
+
+    await link.apply()
+    world.events.length = 0
+
+    const status = await link.apply({ enabled: false })
+
+    expect(status).toMatchObject({ enabled: false, codexFound: true, bridgeRunning: false, lastError: null })
+    expect(world.events).toEqual([
+      `write ${PATHS.settingsFile}`,
+      `write ${PATHS.codexConfig}`,
+      'autostart clear',
+      'stop'
+    ])
+    expect(JSON.parse(world.files.get(PATHS.settingsFile) ?? '')).toEqual({ enabled: false, 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()
+    expect(world.listening).toBe(false)
+  })
+
+  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"}')
+
+    expect(await link.apply()).toMatchObject({ enabled: false, bridgeRunning: false })
+    expect(spawns(world)).toEqual([])
+    expect(world.files.get(PATHS.codexConfig)).toBe(USER_CONFIG)
+
+    expect(await link.apply({ enabled: true })).toMatchObject({ enabled: true, bridgeRunning: true })
+    expect(JSON.parse(world.files.get(PATHS.settingsFile) ?? '')).toEqual({
+      enabled: true,
+      kapsam: 'ide',
+      not: 'ours'
+    })
+    expect(world.files.get(PATHS.codexConfig)).toBe(`${CODEX_LINK_LINE}\r\n${USER_CONFIG}`)
+  })
+
+  it('does not stop a bridge that serves a foreign config when turned off', async () => {
+    const foreign = 'openai_base_url = "http://127.0.0.1:8799/backend-api/codex"\n'
+    const { link, world } = createWorld({ listening: true })
+    world.files.set(PATHS.codexConfig, foreign)
+
+    const status = await link.apply({ enabled: false })
+
+    expect(status).toMatchObject({ enabled: false, foreign: true, bridgeRunning: true })
+    expect(world.events).not.toContain('stop')
+    expect(world.files.get(PATHS.codexConfig)).toBe(foreign)
+    expect(world.listening).toBe(true)
+  })
+
+  it('runs concurrent applies one after another', async () => {
+    const { link, world } = createWorld({ probesUntilUp: 3 })
+
+    const [first, second] = await Promise.all([link.apply(), link.apply({ enabled: false })])
+
+    expect(first.enabled).toBe(true)
+    expect(second).toMatchObject({ enabled: false, bridgeRunning: false })
+    expect(world.files.get(PATHS.codexConfig)).toBe(USER_CONFIG)
+    expect(world.autostart).toBeNull()
+  })
+})
+
+describe('getStatus', () => {
+  it('reads without changing anything', async () => {
+    const { link, world } = createWorld({ listening: true })
+
+    const status = await link.getStatus()
+
+    expect(status).toMatchObject({
+      enabled: true,
+      codexFound: true,
+      venvReady: true,
+      foreign: false,
+      bridgeRunning: true,
+      ideDurum: 'tamam',
+      ideModel: 7,
+      ozet: true
+    })
+    expect(effects(world)).toEqual([])
+  })
+
+  it('reports a bridge that is not answering', async () => {
+    const { link, world } = createWorld()
+
+    expect(await link.getStatus()).toMatchObject({ bridgeRunning: false, ideDurum: null, ideModel: null, ozet: null })
+    expect(effects(world)).toEqual([])
+  })
+})

apps/desktop/electron/codex-link.ts

@@ -0,0 +1,527 @@
+/**
+ * Codex Link ("Codex Bağlama") — decisions and side effects.
+ *
+ * When the feature is on and OpenAI Codex is installed on this machine, the IDE
+ * runs a small local Python bridge, points Codex's `config.toml` at it and
+ * registers the bridge as a login item, so Codex keeps working with the IDE's
+ * models while the IDE itself is closed. Turning it off undoes all three.
+ *
+ * Ordering is the safety property: Codex cannot work at all while its config
+ * points at a dead address, so the config line is written only AFTER the bridge
+ * has answered, and it is taken back out if the bridge cannot be brought up.
+ *
+ * Electron-free on purpose. `createCodexLink` takes every effect as a
+ * dependency (files, spawn, HTTP, registry) so the ordering above is provable
+ * in a unit test; `createNodeCodexLinkDeps` is the real wiring main.ts uses.
+ * The text transformations live in `codex-link-config.ts`.
+ */
+
+import { execFile, spawn } from 'node:child_process'
+import fs from 'node:fs'
+import path from 'node:path'
+
+import {
+  addCodexLinkLine,
+  CODEX_BRIDGE_VERSION,
+  CODEX_LINK_LAUNCHER_NAME,
+  CODEX_LINK_REFRESH_URL,
+  CODEX_LINK_RUN_KEY,
+  CODEX_LINK_RUN_VALUE,
+  CODEX_LINK_STATUS_URL,
+  CODEX_LINK_STOP_URL,
+  codexAutostartPlan,
+  codexBridgeArgs,
+  type CodexBridgeLaunch,
+  inspectCodexConfig,
+  parseCodexLinkSettings,
+  removeCodexLinkLine,
+  serializeCodexBridgeConfig,
+  serializeCodexLinkSettings
+} from './codex-link-config'
+import type { CodexLinkError, CodexLinkIdeState, CodexLinkPatch, CodexLinkStatus } from './codex-link-types'
+import { hiddenWindowsChildOptions } from './windows-child-options'
+
+export type { CodexLinkError, CodexLinkIdeState, CodexLinkPatch, CodexLinkStatus } from './codex-link-types'
+
+export interface CodexLinkPaths {
+  /** `<data root>/codex-baglama.json` */
+  settingsFile: string
+  /** `<data root>/codex-bridge` — the bridge's data folder. */
+  bridgeHome: string
+  hermesHome: string
+  /** `<resources>/codex-bridge/bridge.py` */
+  bridgeScript: string
+  /** Windowless interpreter, preferred. */
+  pythonw: string
+  /** Console interpreter, used hidden when pythonw is absent. */
+  python: string
+  /** `<CODEX_HOME or ~/.codex>/config.toml` */
+  codexConfig: string
+}
+
+export interface CodexLinkDeps {
+  paths: CodexLinkPaths
+  exists: (file: string) => boolean
+  /** null when the file is missing; throws when it cannot be read losslessly. */
+  readText: (file: string) => null | string
+  /** tmp + rename; creates the parent folder. */
+  writeTextAtomic: (file: string, text: string) => void
+  /** Start the bridge detached and hidden; it must outlive the IDE. */
+  spawnBridge: (command: string, args: string[], env: Record<string, string>) => void
+  /** Parsed JSON body, or null when nothing answered within `budgetMs`. */
+  request: (method: 'GET' | 'POST', url: string, budgetMs: number) => Promise<unknown>
+  setAutostart: (command: string) => Promise<void>
+  clearAutostart: () => Promise<void>
+  sleep: (ms: number) => Promise<void>
+  now: () => number
+  log: (message: string) => void
+}
+
+// The single wait this feature owns: how long a freshly spawned bridge gets to
+// answer its status endpoint before the apply gives up.
+export const CODEX_BRIDGE_START_BUDGET_MS = 45_000
+const START_POLL_INTERVAL_MS = 500
+// A probe of an already-running (or absent) local bridge. Loopback answers or
+// refuses at once; the bound only keeps Settings from hanging on a wedged port.
+const PROBE_BUDGET_MS = 2_000
+
+interface BridgeProbe {
+  ideDurum: CodexLinkIdeState | null
+  ideModel: null | number
+  ozet: boolean | null
+  running: boolean
+  surum: null | string
+}
+
+const NOT_RUNNING: BridgeProbe = { ideDurum: null, ideModel: null, ozet: null, running: false, surum: null }
+
+function readProbe(body: unknown): BridgeProbe {
+  if (!body || typeof body !== 'object' || (body as { ok?: unknown }).ok !== true) {
+    return NOT_RUNNING
+  }
+
+  const reply = body as { ide_durum?: unknown; ide_model?: unknown; ozet?: unknown; surum?: unknown }
+  const state = reply.ide_durum
+
+  return {
+    ideDurum: state === 'tamam' || state === 'kapali' || state === 'anahtar-yok' ? state : null,
+    ideModel: typeof reply.ide_model === 'number' && Number.isFinite(reply.ide_model) ? reply.ide_model : null,
+    ozet: typeof reply.ozet === 'boolean' ? reply.ozet : null,
+    running: true,
+    surum: typeof reply.surum === 'string' ? reply.surum : null
+  }
+}
+
+function describe(error: unknown): string {
+  return error instanceof Error ? error.message : String(error)
+}
+
+export interface CodexLink {
+  /** Side-effect free: reads the preference, the files and the status endpoint. */
+  getStatus: () => Promise<CodexLinkStatus>
+  /** Persist `patch.enabled` (if given), make the machine match, report. */
+  apply: (patch?: CodexLinkPatch) => Promise<CodexLinkStatus>
+}
+
+export function createCodexLink(deps: CodexLinkDeps): CodexLink {
+  const { paths } = deps
+  let lastError: CodexLinkError | null = null
+  let queue: Promise<unknown> = Promise.resolve()
+
+  const launch: CodexBridgeLaunch = {
+    bridgeHome: paths.bridgeHome,
+    bridgeScript: paths.bridgeScript,
+    hermesHome: paths.hermesHome
+  }
+
+  const fail = (code: CodexLinkError, error?: unknown) => {
+    lastError = code
+    deps.log(`[codex-link] ${code}${error === undefined ? '' : `: ${describe(error)}`}`)
+  }
+
+  const readSettings = () => {
+    try {
+      return parseCodexLinkSettings(deps.readText(paths.settingsFile))
+    } catch {
+      return parseCodexLinkSettings(null)
+    }
+  }
+
+  // The interpreter to run the bridge with, or null while the IDE's own
+  // first-run setup has not produced the venv yet.
+  const interpreter = () =>
+    deps.exists(paths.pythonw) ? paths.pythonw : deps.exists(paths.python) ? paths.python : null
+
+  // The owner of Codex's base URL. An unreadable config counts as foreign for
+  // the purpose of "do not touch": we only edit what we could read back intact.
+  const readCodexConfig = (): { found: boolean; owner: 'absent' | 'foreign' | 'ours'; text: null | string } => {
+    if (!deps.exists(paths.codexConfig)) {
+      return { found: false, owner: 'absent', text: null }
+    }
+
+    try {
+      const text = deps.readText(paths.codexConfig)
+
+      return text === null
+        ? { found: false, owner: 'absent', text: null }
+        : { found: true, owner: inspectCodexConfig(text), text }
+    } catch (error) {
+      deps.log(`[codex-link] config.toml could not be read: ${describe(error)}`)
+
+      return { found: true, owner: 'foreign', text: null }
+    }
+  }
+
+  const probe = async (budgetMs = PROBE_BUDGET_MS): Promise<BridgeProbe> => {
+    try {
+      return readProbe(await deps.request('GET', CODEX_LINK_STATUS_URL, budgetMs))
+    } catch {
+      return NOT_RUNNING
+    }
+  }
+
+  const statusFrom = (
+    enabled: boolean,
+    config: { found: boolean; owner: string },
+    bridge: BridgeProbe
+  ): CodexLinkStatus => ({
+    enabled,
+    codexFound: config.found,
+    venvReady: interpreter() !== null,
+    foreign: config.owner === 'foreign',
+    bridgeRunning: bridge.running,
+    ideDurum: bridge.ideDurum,
+    ideModel: bridge.ideModel,
+    ozet: bridge.ozet,
+    lastError
+  })
+
+  const removeOurLine = (text: null | string): boolean => {
+    if (text === null) {
+      return true
+    }
+
+    const edit = removeCodexLinkLine(text)
+
+    if (!edit.changed) {
+      return true
+    }
+
+    try {
+      deps.writeTextAtomic(paths.codexConfig, edit.text)
+
+      return true
+    } catch (error) {
+      fail('config-write-failed', error)
+
+      return false
+    }
+  }
+
+  // Off: take back everything we put there. Each step is independent — a
+  // failure in one must not leave the others in place.
+  const tearDown = async (config: ReturnType<typeof readCodexConfig>): Promise<BridgeProbe> => {
+    removeOurLine(config.text)
+
+    try {
+      await deps.clearAutostart()
+    } catch (error) {
+      fail('autostart-failed', error)
+    }
+
+    // A foreign config means whatever listens on the port serves someone
+    // else's setup; stopping it would break a bridge we do not own.
+    if (config.owner === 'foreign') {
+      return probe()
+    }
+
+    try {
+      // No answer means nothing of ours is listening; leave it alone.
+      return (await deps.request('POST', CODEX_LINK_STOP_URL, PROBE_BUDGET_MS)) === null ? probe() : NOT_RUNNING
+    } catch {
+      return probe()
+    }
+  }
+
+  const startBridge = async (python: string): Promise<BridgeProbe> => {
+    try {
+      deps.spawnBridge(python, codexBridgeArgs(launch), {
+        AITURK_CODEX_BRIDGE_HOME: paths.bridgeHome,
+        HERMES_HOME: paths.hermesHome
+      })
+    } catch (error) {
+      deps.log(`[codex-link] bridge spawn failed: ${describe(error)}`)
+
+      return NOT_RUNNING
+    }
+
+    const deadline = deps.now() + CODEX_BRIDGE_START_BUDGET_MS
+
+    for (;;) {
+      const remaining = deadline - deps.now()
+
+      if (remaining <= 0) {
+        return NOT_RUNNING
+      }
+
+      const result = await probe(Math.min(PROBE_BUDGET_MS, remaining))
+
+      if (result.running) {
+        return result
+      }
+
+      await deps.sleep(Math.min(START_POLL_INTERVAL_MS, Math.max(0, deadline - deps.now())))
+    }
+  }
+
+  // On: bridge.json → bridge up (verified) → config.toml → login item.
+  const setUp = async (python: string, config: ReturnType<typeof readCodexConfig>): Promise<BridgeProbe> => {
+    if (!deps.exists(paths.bridgeScript)) {
+      fail('bridge-missing', paths.bridgeScript)
+
+      return probe()
+    }
+
+    try {
+      deps.writeTextAtomic(path.join(paths.bridgeHome, 'bridge.json'), serializeCodexBridgeConfig())
+    } catch (error) {
+      fail('bridge-config-failed', error)
+
+      return probe()
+    }
+
+    let bridge = await probe()
+
+    if (bridge.running && bridge.surum !== CODEX_BRIDGE_VERSION) {
+      // A bridge from an older IDE build is still listening: replace it.
+      try {
+        await deps.request('POST', CODEX_LINK_STOP_URL, PROBE_BUDGET_MS)
+      } catch {
+        // It stops answering once it exits; the start below verifies the new one.
+      }
+
+      await deps.sleep(START_POLL_INTERVAL_MS * 2)
+      bridge = NOT_RUNNING
+    }
+
+    if (bridge.running) {
+      // Already up: have it re-read the IDE session and model list now (a sign-in
+      // since its last periodic refresh would otherwise show up minutes later).
+      try {
+        const refreshed = readProbe(await deps.request('POST', CODEX_LINK_REFRESH_URL, CODEX_BRIDGE_START_BUDGET_MS))
+
+        bridge = refreshed.running ? refreshed : bridge
+      } catch {
+        // The status it already gave stays valid.
+      }
+    } else {
+      bridge = await startBridge(python)
+    }
+
+    if (!bridge.running) {
+      fail('bridge-start-failed')
+      // Fail open: a line left over from an earlier run would now point Codex
+      // at a dead address. Without it Codex simply talks to OpenAI directly.
+      removeOurLine(config.text)
+
+      return bridge
+    }
+
+    const edit = addCodexLinkLine(config.text ?? '')
+
+    if (edit.changed) {
+      try {
+        deps.writeTextAtomic(paths.codexConfig, edit.text)
+      } catch (error) {
+        fail('config-write-failed', error)
+
+        return bridge
+      }
+    }
+
+    // Rewritten on every apply: an IDE update can move the bridge script.
+    try {
+      const plan = codexAutostartPlan(python, launch, path.join(paths.bridgeHome, CODEX_LINK_LAUNCHER_NAME))
+
+      if (!plan) {
+        throw new Error('the bridge command does not fit a Run value')
+      }
+
+      if (plan.launcher) {
+        deps.writeTextAtomic(plan.launcher.path, plan.launcher.source)
+      }
+
+      await deps.setAutostart(plan.command)
+    } catch (error) {
+      fail('autostart-failed', error)
+    }
+
+    return bridge
+  }
+
+  const run = async (patch?: CodexLinkPatch): Promise<CodexLinkStatus> => {
+    lastError = null
+
+    if (typeof patch?.enabled === 'boolean') {
+      try {
+        deps.writeTextAtomic(paths.settingsFile, serializeCodexLinkSettings(readSettings().stored, patch.enabled))
+      } 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.
+        fail('settings-write-failed', error)
+      }
+    }
+
+    const { enabled } = readSettings()
+    const config = readCodexConfig()
+
+    if (!enabled) {
+      return statusFrom(enabled, config, await tearDown(config))
+    }
+
+    const python = interpreter()
+
+    if (!config.found || !python || config.owner === 'foreign') {
+      return statusFrom(enabled, config, await probe())
+    }
+
+    return statusFrom(enabled, config, await setUp(python, config))
+  }
+
+  return {
+    getStatus: async () => statusFrom(readSettings().enabled, readCodexConfig(), await probe()),
+    // One apply at a time: two interleaved runs could write the config line
+    // from one while the other is tearing the bridge down.
+    apply: patch => {
+      const next = queue.then(() => run(patch))
+      queue = next.catch(() => undefined)
+
+      return next
+    }
+  }
+}
+
+// ── Real dependencies ───────────────────────────────────────────────────────
+
+function writeTextAtomic(file: string, text: string): void {
+  fs.mkdirSync(path.dirname(file), { recursive: true })
+  const tmp = `${file}.${process.pid}.tmp`
+
+  try {
+    fs.writeFileSync(tmp, text, 'utf8')
+    fs.renameSync(tmp, file)
+  } catch (error) {
+    fs.rmSync(tmp, { force: true })
+
+    throw error
+  }
+}
+
+// Decode as UTF-8 and insist the bytes survive the round trip. A config in
+// another encoding would be corrupted by a rewrite, so refuse to return it.
+function readTextLossless(file: string): null | string {
+  let bytes: Buffer
+
+  try {
+    bytes = fs.readFileSync(file)
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+      return null
+    }
+
+    throw error
+  }
+
+  const text = bytes.toString('utf8')
+
+  if (!Buffer.from(text, 'utf8').equals(bytes)) {
+    throw new Error('file is not valid UTF-8')
+  }
+
+  return text
+}
+
+function runReg(args: string[]): Promise<{ code: number; stderr: string }> {
+  const reg = path.join(process.env.SystemRoot || 'C:\\Windows', 'System32', 'reg.exe')
+
+  return new Promise(resolve => {
+    execFile(reg, args, hiddenWindowsChildOptions({ encoding: 'utf8' }), (error, _stdout, stderr) => {
+      const exit = error ? (typeof (error as { code?: unknown }).code === 'number' ? (error as any).code : 1) : 0
+      resolve({ code: exit, stderr: String(stderr || (error ? error.message : '')).trim() })
+    })
+  })
+}
+
+async function requestJson(method: 'GET' | 'POST', url: string, budgetMs: number): Promise<unknown> {
+  try {
+    const response = await fetch(url, { method, signal: AbortSignal.timeout(Math.max(1, budgetMs)) })
+
+    return response.ok ? await response.json() : null
+  } catch {
+    return null
+  }
+}
+
+export function createNodeCodexLinkDeps(paths: CodexLinkPaths, log: (message: string) => void): CodexLinkDeps {
+  return {
+    paths,
+    exists: file => fs.existsSync(file),
+    readText: readTextLossless,
+    writeTextAtomic,
+    spawnBridge: (command, args, env) => {
+      fs.mkdirSync(paths.bridgeHome, { recursive: true })
+
+      // Detached with no stdio and unref'd: the bridge is deliberately NOT a
+      // child the IDE cleans up on quit — Codex depends on it staying alive.
+      const child = spawn(
+        command,
+        args,
+        hiddenWindowsChildOptions({
+          cwd: paths.bridgeHome,
+          detached: true,
+          env: { ...process.env, ...env },
+          stdio: 'ignore'
+        }) as any
+      )
+
+      child.on('error', error => log(`[codex-link] bridge process error: ${error.message}`))
+      child.unref()
+    },
+    request: requestJson,
+    setAutostart: async command => {
+      const result = await runReg([
+        'add',
+        CODEX_LINK_RUN_KEY,
+        '/v',
+        CODEX_LINK_RUN_VALUE,
+        '/t',
+        'REG_SZ',
+        '/d',
+        command,
+        '/f'
+      ])
+
+      if (result.code !== 0) {
+        throw new Error(`reg add exited ${result.code}: ${result.stderr}`)
+      }
+    },
+    clearAutostart: async () => {
+      // `reg delete` fails on a value that is not there; absent is already the
+      // state we want, so look first.
+      const present = await runReg(['query', CODEX_LINK_RUN_KEY, '/v', CODEX_LINK_RUN_VALUE])
+
+      if (present.code !== 0) {
+        return
+      }
+
+      const result = await runReg(['delete', CODEX_LINK_RUN_KEY, '/v', CODEX_LINK_RUN_VALUE, '/f'])
+
+      if (result.code !== 0) {
+        throw new Error(`reg delete exited ${result.code}: ${result.stderr}`)
+      }
+    },
+    sleep: ms => new Promise(resolve => setTimeout(resolve, ms)),
+    now: () => Date.now(),
+    log
+  }
+}

apps/desktop/electron/main.ts

@@ -36,6 +36,7 @@ import { WebSocket as RelayWebSocket } from 'ws'
 
 import { classifyActiveRuntime, needsPackagedRuntimeUpgrade } from './active-runtime-state'
 import { createAiturkCliRunner, createAiturkLogin } from './aiturk-login'
+import { createCodexLink, createNodeCodexLinkDeps } from './codex-link'
 import { createMobileBackendResolver } from './mobile-backend'
 import {
   createMobileLink,
@@ -13091,6 +13092,9 @@ async function startHermes() {
     // accumulated count of the resolved episode.
     bootstrapRepairAttempt = 0
 
+    // The local backend is up, so the venv the Codex bridge runs on exists.
+    syncCodexLinkOnBoot()
+
     return {
       baseUrl,
       mode: 'local',
@@ -17182,6 +17186,72 @@ ipcMain.handle('hermes:quick-entry:settings:set', async (_event, patch) => {
   return applyQuickEntrySettings(next)
 })
 
+// Codex Link ("Codex Bağlama"): lets the OpenAI Codex on this machine use the
+// IDE's models through a small local bridge. Main owns the preference file, the
+// bridge process, Codex's config line and the login item; Settings reads the
+// resulting state and asks for changes over IPC. Windows only (the login item is
+// a Run-key value). All decisions live in electron/codex-link.ts.
+const AITURK_IDE_DATA_ROOT = path.dirname(HERMES_HOME)
+
+const codexLink = createCodexLink(
+  createNodeCodexLinkDeps(
+    {
+      settingsFile: path.join(AITURK_IDE_DATA_ROOT, 'codex-baglama.json'),
+      bridgeHome: path.join(AITURK_IDE_DATA_ROOT, 'codex-bridge'),
+      hermesHome: HERMES_HOME,
+      bridgeScript: IS_PACKAGED
+        ? path.join(process.resourcesPath, 'codex-bridge', 'bridge.py')
+        : path.join(APP_ROOT, 'assets', 'codex-bridge', 'bridge.py'),
+      pythonw: path.join(VENV_ROOT, 'Scripts', 'pythonw.exe'),
+      python: getVenvPython(VENV_ROOT),
+      codexConfig: path.join(process.env.CODEX_HOME || path.join(app.getPath('home'), '.codex'), 'config.toml')
+    },
+    rememberLog
+  )
+)
+
+let codexLinkBootSynced = false
+
+// Once per launch, after the local backend is ready. Never allowed to affect
+// startup: it is not awaited and every failure ends in the log.
+function syncCodexLinkOnBoot() {
+  if (!IS_WINDOWS || codexLinkBootSynced) {
+    return
+  }
+
+  codexLinkBootSynced = true
+  void codexLink.apply().catch(error => rememberLog(`[codex-link] boot sync failed: ${error?.message ?? error}`))
+}
+
+// Only the primary window's top-level frame may read or change the link.
+function assertCodexLinkSender(event) {
+  const contents = mainWindow && !mainWindow.isDestroyed() ? mainWindow.webContents : null
+
+  if (
+    !IS_WINDOWS ||
+    !contents ||
+    event.sender !== contents ||
+    (event.senderFrame && event.senderFrame !== contents.mainFrame)
+  ) {
+    throw new Error('codex-link:unavailable')
+  }
+}
+
+ipcMain.handle('aiturk:codex-link:get', async event => {
+  assertCodexLinkSender(event)
+
+  return codexLink.getStatus()
+})
+
+ipcMain.handle('aiturk:codex-link:set', async (event, patch) => {
+  assertCodexLinkSender(event)
+
+  return codexLink.apply({
+    enabled: typeof patch?.enabled === 'boolean' ? patch.enabled : undefined,
+    sync: patch?.sync === true
+  })
+})
+
 // Quick window → main → PRIMARY renderer. We never submit here: the renderer
 // owns the one prompt-submit path, and forwarding keeps it that way. The
 // payload is `{ target, text }` — target routing (current chat / a picked

apps/desktop/electron/preload.ts

@@ -290,6 +290,16 @@ contextBridge.exposeInMainWorld('hermesDesktop', {
     // Opens the "Telefon bağlantısı" window (electron/mobile-host.mjs).
     open: () => ipcRenderer.invoke('aiturk:mobile:open')
   },
+  // "Codex Bağlama" (electron/codex-link.ts). Windows only: absent elsewhere,
+  // so Settings does not offer a page that cannot do anything.
+  ...(process.platform === 'win32'
+    ? {
+        codexLink: {
+          get: () => ipcRenderer.invoke('aiturk:codex-link:get'),
+          set: patch => ipcRenderer.invoke('aiturk:codex-link:set', patch)
+        }
+      }
+    : {}),
   mcpOauth: {
     // One-shot loopback listener for MCP OAuth against remote backends: bind
     // on this machine, hand redirectUri to mcp.servers.oauth.start, then wait

apps/desktop/package.json

@@ -2,7 +2,7 @@
   "name": "aiturk-ide",
   "productName": "AITURK IDE",
   "private": true,
-  "version": "1.0.0-beta.20",
+  "version": "1.0.0-beta.27",
   "description": "TurkServis resmi yapay zekâ geliştirme ortamı. Hermes Agent tabanlıdır.",
   "author": "AITURK / TurkServis",
   "repository": {
@@ -299,6 +299,16 @@
             "*.dll",
             "manifest.json"
           ]
+        },
+        {
+          "from": "assets/codex-bridge",
+          "to": "codex-bridge",
+          "filter": [
+            "**/*.py",
+            "**/*.pyd",
+            "**/LICENSE",
+            "!test_*.py"
+          ]
         }
       ]
     },

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

@@ -0,0 +1,193 @@
+import { cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+import { I18nProvider } from '@/i18n/context'
+
+import type { CodexLinkStatus } from '../../../electron/codex-link-types'
+
+import { CodexLinkSettings } from './codex-link-settings'
+
+const notifyError = vi.hoisted(() => vi.fn())
+vi.mock('@/store/notifications', () => ({ notifyError }))
+
+const RUNNING: CodexLinkStatus = {
+  enabled: true,
+  codexFound: true,
+  venvReady: true,
+  foreign: false,
+  bridgeRunning: true,
+  ideDurum: 'tamam',
+  ideModel: 12,
+  ozet: true,
+  lastError: null
+}
+
+const get = vi.fn<() => Promise<CodexLinkStatus>>()
+const set = vi.fn<(patch: { enabled?: boolean; sync?: boolean }) => Promise<CodexLinkStatus>>()
+
+function renderPage(locale: 'en' | 'tr' = 'tr') {
+  return render(
+    <I18nProvider configClient={null} initialLocale={locale}>
+      <CodexLinkSettings />
+    </I18nProvider>
+  )
+}
+
+function statusTexts() {
+  return screen.getAllByRole('listitem').map(item => item.textContent)
+}
+
+beforeEach(() => {
+  ;(window as unknown as { hermesDesktop: unknown }).hermesDesktop = { codexLink: { get, set } }
+})
+
+afterEach(() => {
+  cleanup()
+  vi.resetAllMocks()
+  delete (window as unknown as { hermesDesktop?: unknown }).hermesDesktop
+})
+
+describe('Codex Link settings', () => {
+  it('explains the feature and shows a healthy link in Turkish', async () => {
+    get.mockResolvedValue(RUNNING)
+    renderPage()
+
+    expect(await screen.findByText('Köprü çalışıyor.')).toBeTruthy()
+    expect(statusTexts()).toEqual(['Bu bilgisayarda Codex bulundu.', 'Köprü çalışıyor.', "Codex'e 12 model eklendi."])
+    expect(
+      screen.getByText(
+        "AITURK IDE'deki modelleri ve comboları bu bilgisayardaki Codex'e ekler; modeller arasında geçerken sohbet bağlamını korur."
+      )
+    ).toBeTruthy()
+    expect(screen.getByText("Codex'te yeni modelleri görmek için Codex'i yeniden açın.")).toBeTruthy()
+    expect(screen.getByRole('switch', { name: 'Codex Bağlama' }).getAttribute('aria-checked')).toBe('true')
+    expect(set).not.toHaveBeenCalled()
+  })
+
+  it('renders in English for other locales', async () => {
+    get.mockResolvedValue(RUNNING)
+    renderPage('en')
+
+    expect(await screen.findByText('The bridge is running.')).toBeTruthy()
+    expect(statusTexts()).toEqual([
+      'Codex was found on this computer.',
+      'The bridge is running.',
+      '12 models added to Codex.'
+    ])
+    expect(screen.getByRole('button', { name: 'Sync now' })).toBeTruthy()
+  })
+
+  it('says only that Codex is missing when it is not installed', async () => {
+    get.mockResolvedValue({ ...RUNNING, codexFound: false, bridgeRunning: false, ideDurum: null, ideModel: null })
+    renderPage()
+
+    expect(await screen.findByText('Bu bilgisayarda Codex bulunamadı.')).toBeTruthy()
+    expect(statusTexts()).toEqual(['Bu bilgisayarda Codex bulunamadı.'])
+  })
+
+  it('says another bridge is in charge and does not claim ours is running', async () => {
+    get.mockResolvedValue({ ...RUNNING, foreign: true })
+    renderPage()
+
+    expect(await screen.findByText(/başka bir köprü kullanıyor/)).toBeTruthy()
+    expect(statusTexts()).toEqual([
+      'Bu bilgisayarda Codex bulundu.',
+      'Bu bilgisayarda Codex başka bir köprü kullanıyor; ayarına dokunulmadı.'
+    ])
+  })
+
+  it('says it is waiting for the IDE setup', async () => {
+    get.mockResolvedValue({ ...RUNNING, venvReady: false, bridgeRunning: false, ideDurum: null, ideModel: null })
+    renderPage()
+
+    expect(await screen.findByText('IDE kurulumu tamamlanınca etkinleşecek.')).toBeTruthy()
+    expect(screen.queryByText('Köprü çalışmıyor.')).toBeNull()
+  })
+
+  it('asks for a sign-in when the bridge has no IDE session', async () => {
+    get.mockResolvedValue({ ...RUNNING, ideDurum: 'anahtar-yok', ideModel: 0 })
+    renderPage()
+
+    expect(await screen.findByText('IDE oturumu bulunamadı, giriş yapın.')).toBeTruthy()
+    expect(screen.queryByText(/model eklendi/)).toBeNull()
+  })
+
+  it('shows a stopped bridge together with the last error', async () => {
+    get.mockResolvedValue({
+      ...RUNNING,
+      bridgeRunning: false,
+      ideDurum: null,
+      ideModel: null,
+      lastError: 'bridge-start-failed'
+    })
+    renderPage()
+
+    expect(await screen.findByText('Köprü çalışmıyor.')).toBeTruthy()
+    expect(screen.getByText('Köprü başlatılamadı; Codex ayarına dokunulmadı.')).toBeTruthy()
+  })
+
+  it('turns the link off through the bridge and adopts the reply', async () => {
+    get.mockResolvedValue(RUNNING)
+    set.mockResolvedValue({ ...RUNNING, enabled: false, bridgeRunning: false, ideDurum: null, ideModel: null })
+    renderPage()
+
+    await screen.findByText('Köprü çalışıyor.')
+    fireEvent.click(screen.getByRole('switch', { name: 'Codex Bağlama' }))
+
+    expect(set).toHaveBeenCalledWith({ enabled: false })
+    expect(await screen.findByText('Codex Bağlama kapalı. Codex kendi ayarlarıyla çalışıyor.')).toBeTruthy()
+    expect(screen.getByRole('switch', { name: 'Codex Bağlama' }).getAttribute('aria-checked')).toBe('false')
+  })
+
+  it('rolls the switch back and reports when the change fails', async () => {
+    get.mockResolvedValue(RUNNING)
+    set.mockRejectedValue(new Error('codex-link:unavailable'))
+    renderPage()
+
+    await screen.findByText('Köprü çalışıyor.')
+    fireEvent.click(screen.getByRole('switch', { name: 'Codex Bağlama' }))
+
+    await waitFor(() => expect(notifyError).toHaveBeenCalledWith(expect.any(Error), 'Codex Bağlama değiştirilemedi.'))
+    expect(screen.getByRole('switch', { name: 'Codex Bağlama' }).getAttribute('aria-checked')).toBe('true')
+    expect(screen.getByText('Köprü çalışıyor.')).toBeTruthy()
+  })
+
+  it('syncs on demand and keeps the button disabled while it runs', async () => {
+    get.mockResolvedValue({ ...RUNNING, bridgeRunning: false, ideDurum: null, ideModel: null })
+
+    let finish: (status: CodexLinkStatus) => void = () => undefined
+
+    set.mockReturnValue(
+      new Promise<CodexLinkStatus>(resolve => {
+        finish = resolve
+      })
+    )
+    renderPage()
+
+    await screen.findByText('Köprü çalışmıyor.')
+    fireEvent.click(screen.getByRole('button', { name: 'Şimdi eşitle' }))
+
+    expect(set).toHaveBeenCalledTimes(1)
+    expect(set).toHaveBeenCalledWith({ sync: true })
+
+    const pending = screen.getByRole('button', { name: 'Eşitleniyor…' }) as HTMLButtonElement
+
+    expect(pending.disabled).toBe(true)
+    fireEvent.click(pending)
+    expect(set).toHaveBeenCalledTimes(1)
+
+    finish(RUNNING)
+
+    expect(await screen.findByText('Köprü çalışıyor.')).toBeTruthy()
+    expect((screen.getByRole('button', { name: 'Şimdi eşitle' }) as HTMLButtonElement).disabled).toBe(false)
+  })
+
+  it('offers nothing to click where the desktop bridge is absent', () => {
+    delete (window as unknown as { hermesDesktop?: unknown }).hermesDesktop
+    renderPage()
+
+    expect(screen.getByText('Codex Bağlama yalnızca Windows masaüstü uygulamasında kullanılabilir.')).toBeTruthy()
+    expect(screen.queryByRole('switch')).toBeNull()
+    expect(get).not.toHaveBeenCalled()
+  })
+})

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

@@ -0,0 +1,233 @@
+import { useCallback, useEffect, useRef, useState } from 'react'
+
+import { Button } from '@/components/ui/button'
+import { Switch } from '@/components/ui/switch'
+import { type CodexLinkCopy, useCodexLinkCopy } from '@/i18n/codex-link'
+import { triggerHaptic } from '@/lib/haptics'
+import { AlertTriangle, Check, CircleIcon, Link, RefreshCw } from '@/lib/icons'
+import { cn } from '@/lib/utils'
+import { notifyError } from '@/store/notifications'
+
+import type { CodexLinkPatch, CodexLinkStatus } from '../../../electron/codex-link-types'
+
+import { EmptyState, ListRow, ListRowSkeleton, SettingsContent, SettingsSection } from './primitives'
+
+type Tone = 'muted' | 'ok' | 'warn'
+
+interface StatusLine {
+  id: string
+  text: string
+  tone: Tone
+}
+
+/**
+ * What the user needs to know, top-down, stopping at the first fact that makes
+ * the rest moot (no Codex → nothing else to say; another bridge → ours is not
+ * involved; setup pending → the bridge cannot be running yet).
+ */
+export function codexLinkStatusLines(status: CodexLinkStatus, copy: CodexLinkCopy): StatusLine[] {
+  const lines: StatusLine[] = []
+  const error = status.lastError ? [{ id: 'error', text: copy.errors[status.lastError], tone: 'warn' as const }] : []
+
+  if (!status.codexFound) {
+    return [{ id: 'codex', text: copy.codexMissing, tone: 'muted' }, ...error]
+  }
+
+  lines.push({ id: 'codex', text: copy.codexFound, tone: 'ok' })
+
+  if (status.foreign) {
+    return [...lines, { id: 'foreign', text: copy.foreign, tone: 'warn' }, ...error]
+  }
+
+  if (!status.enabled) {
+    return [...lines, { id: 'off', text: copy.off, tone: 'muted' }, ...error]
+  }
+
+  if (!status.venvReady) {
+    return [...lines, { id: 'venv', text: copy.venvPending, tone: 'muted' }, ...error]
+  }
+
+  if (!status.bridgeRunning) {
+    return [...lines, { id: 'bridge', text: copy.bridgeStopped, tone: 'warn' }, ...error]
+  }
+
+  lines.push({ id: 'bridge', text: copy.bridgeRunning, tone: 'ok' })
+
+  if (status.ideDurum === 'anahtar-yok') {
+    lines.push({ id: 'ide', text: copy.signIn, tone: 'warn' })
+  } else if (status.ideDurum === 'tamam' && status.ideModel !== null) {
+    lines.push({ id: 'ide', text: copy.models(status.ideModel), tone: 'ok' })
+  }
+
+  return [...lines, ...error]
+}
+
+const TONE_ICON = { muted: CircleIcon, ok: Check, warn: AlertTriangle } as const
+
+const TONE_CLASS: Record<Tone, string> = {
+  muted: 'text-(--ui-text-tertiary)',
+  ok: 'text-(--ui-text-secondary)',
+  warn: 'text-amber-500/90'
+}
+
+// Phone-sized hit area around the compact switch: the visible control keeps the
+// design-system size, the label that wraps it is the 44px target.
+const TOUCH_TARGET = 'flex min-h-11 min-w-11 cursor-pointer items-center @2xl:justify-end'
+
+/**
+ * Settings → Codex Link. Main owns everything real (the preference file, the
+ * bridge, Codex's config, the login item); this page reads the state it reports
+ * and asks for changes, adopting whatever comes back as the truth.
+ */
+export function CodexLinkSettings() {
+  const copy = useCodexLinkCopy()
+  const bridge = typeof window === 'undefined' ? undefined : window.hermesDesktop?.codexLink
+  const [status, setStatus] = useState<CodexLinkStatus | null>(null)
+  const [loadFailed, setLoadFailed] = useState(false)
+  const [busy, setBusy] = useState<'sync' | 'toggle' | null>(null)
+  // A slow initial read must not overwrite the answer to a newer change.
+  const generation = useRef(0)
+
+  useEffect(() => {
+    if (!bridge) {
+      return
+    }
+
+    const ticket = generation.current
+
+    bridge.get().then(
+      next => {
+        if (generation.current === ticket) {
+          setStatus(next)
+        }
+      },
+      () => {
+        if (generation.current === ticket) {
+          setLoadFailed(true)
+        }
+      }
+    )
+  }, [bridge])
+
+  const change = useCallback(
+    async (patch: CodexLinkPatch, kind: 'sync' | 'toggle') => {
+      if (!bridge || busy) {
+        return
+      }
+
+      const before = status
+      generation.current += 1
+      setBusy(kind)
+      setLoadFailed(false)
+
+      // The switch moves at once; main's reply (or the rollback) has the last word.
+      if (typeof patch.enabled === 'boolean' && before) {
+        setStatus({ ...before, enabled: patch.enabled })
+      }
+
+      try {
+        setStatus(await bridge.set(patch))
+      } catch (error) {
+        setStatus(before)
+        notifyError(error, copy.saveFailed)
+      } finally {
+        setBusy(null)
+      }
+    },
+    [bridge, busy, copy.saveFailed, status]
+  )
+
+  if (!bridge) {
+    return (
+      <SettingsContent>
+        <EmptyState description={copy.unavailable} title={copy.title} />
+      </SettingsContent>
+    )
+  }
+
+  const lines = status ? codexLinkStatusLines(status, copy) : []
+
+  return (
+    <SettingsContent>
+      <SettingsSection icon={Link} title={copy.title}>
+        <ListRow
+          action={
+            <label className={TOUCH_TARGET}>
+              <Switch
+                aria-label={copy.title}
+                checked={status?.enabled ?? true}
+                disabled={!status || busy !== null}
+                onCheckedChange={enabled => {
+                  triggerHaptic('selection')
+                  void change({ enabled }, 'toggle')
+                }}
+              />
+            </label>
+          }
+          description={copy.description}
+          title={copy.title}
+        />
+
+        {!status && !loadFailed && <ListRowSkeleton wide />}
+
+        {loadFailed && !status && (
+          <p className="py-3 text-[length:var(--conversation-caption-font-size)] text-amber-500/90" role="alert">
+            {copy.loadFailed}
+          </p>
+        )}
+
+        {status && (
+          <ListRow
+            below={
+              <ul aria-live="polite" className="mt-1.5 grid gap-1.5">
+                {lines.map(line => {
+                  const Icon = TONE_ICON[line.tone]
+
+                  return (
+                    <li
+                      className={cn(
+                        'flex min-w-0 items-start gap-2 text-[length:var(--conversation-caption-font-size)] leading-(--conversation-caption-line-height)',
+                        TONE_CLASS[line.tone]
+                      )}
+                      data-tone={line.tone}
+                      key={line.id}
+                    >
+                      <Icon aria-hidden className="mt-0.5 size-3.5 shrink-0" />
+                      <span className="min-w-0 break-words">{line.text}</span>
+                    </li>
+                  )
+                })}
+              </ul>
+            }
+            title={copy.statusTitle}
+            wide
+          />
+        )}
+
+        <ListRow
+          action={
+            <Button
+              className="min-h-11 w-full @2xl:w-auto"
+              disabled={!status || busy !== null}
+              onClick={() => {
+                triggerHaptic('open')
+                void change({ sync: true }, 'sync')
+              }}
+              type="button"
+              variant="secondary"
+            >
+              <RefreshCw />
+              {busy === 'sync' ? copy.syncing : copy.sync}
+            </Button>
+          }
+          description={copy.syncDesc}
+          title={copy.syncTitle}
+        />
+
+        <p className="pt-2 text-[length:var(--conversation-caption-font-size)] leading-(--conversation-caption-line-height) text-(--ui-text-tertiary)">
+          {copy.restartNote}
+        </p>
+      </SettingsSection>
+    </SettingsContent>
+  )
+}

apps/desktop/src/app/settings/index.tsx

@@ -9,6 +9,7 @@ import { Tip } from '@/components/ui/tooltip'
 import { getHermesConfigDefaults, getHermesConfigRecord, saveHermesConfig } from '@/hermes'
 import { useI18n } from '@/i18n'
 import { useAiturkCopy } from '@/i18n/aiturk'
+import { useCodexLinkCopy } from '@/i18n/codex-link'
 import { triggerHaptic } from '@/lib/haptics'
 import {
   Archive,
@@ -20,6 +21,7 @@ import {
   Info,
   Keyboard,
   KeyRound,
+  Link,
   Package,
   RefreshCw,
   Search,
@@ -46,6 +48,7 @@ import { SKILLS_ROUTE } from '../routes'
 import { AboutSettings } from './about-settings'
 import { AppearanceSettings } from './appearance-settings'
 import { BillingSettings } from './billing'
+import { CodexLinkSettings } from './codex-link-settings'
 import { ConfigSettings } from './config-settings'
 import { SECTIONS } from './constants'
 import { GatewaySettings } from './gateway-settings'
@@ -68,6 +71,7 @@ const SETTINGS_VIEWS: readonly SettingsViewId[] = [
   'keys',
   'notifications',
   'billing',
+  'codex-link',
   'plugins',
   'sessions',
   'about'
@@ -76,6 +80,7 @@ const SETTINGS_VIEWS: readonly SettingsViewId[] = [
 export function SettingsView({ onClose, onConfigSaved, onMainModelChanged }: SettingsPageProps) {
   const { t } = useI18n()
   const aiturkCopy = useAiturkCopy()
+  const codexLinkCopy = useCodexLinkCopy()
   const navigate = useNavigate()
   const { hash, pathname, search } = useLocation()
 
@@ -267,6 +272,19 @@ export function SettingsView({ onClose, onConfigSaved, onMainModelChanged }: Set
             }
           ]
         : []),
+      // "Codex Bağlama": present only where the desktop bridge offers it
+      // (Windows). A stale ?tab=codex-link elsewhere renders its own notice.
+      ...(window.hermesDesktop?.codexLink
+        ? [
+            {
+              active: activeView === 'codex-link',
+              icon: Link,
+              id: 'codex-link',
+              label: codexLinkCopy.nav,
+              onSelect: () => setActiveView('codex-link')
+            }
+          ]
+        : []),
       {
         active: activeView === 'keybinds',
         icon: Keyboard,
@@ -320,7 +338,7 @@ export function SettingsView({ onClose, onConfigSaved, onMainModelChanged }: Set
         onSelect: () => setActiveView('about')
       }
     ],
-    [activeView, keysView, providerView, t, aiturkCopy, setActiveView, openProviderView, openKeysView]
+    [activeView, keysView, providerView, t, aiturkCopy, codexLinkCopy, setActiveView, openProviderView, openKeysView]
   )
 
   // Type-to-search: printable keystrokes on the Settings surface (outside any
@@ -439,6 +457,8 @@ export function SettingsView({ onClose, onConfigSaved, onMainModelChanged }: Set
       <BillingSettings />
     ) : activeView === 'plugins' ? (
       <PluginsSettings />
+    ) : activeView === 'codex-link' ? (
+      <CodexLinkSettings />
     ) : (
       <SessionsSettings />
     )

apps/desktop/src/app/settings/types.ts

@@ -7,6 +7,7 @@ import type { EnvVarInfo } from '@/types/hermes'
 export type SettingsView =
   | 'about'
   | 'billing'
+  | 'codex-link'
   | 'connections'
   | 'gateway'
   | 'keybinds'

apps/desktop/src/global.d.ts

@@ -1,6 +1,7 @@
 import type { GatewayWsUrlResult } from '@hermes/shared'
 import type { TranslucencyState } from '@hermes/shared/translucency'
 
+import type { CodexLinkPatch, CodexLinkStatus } from '../electron/codex-link-types'
 import type { PoolLimits } from '../electron/pool-limits'
 
 import type { WakeIndicatorState } from './lib/wake-indicator'
@@ -335,6 +336,13 @@ declare global {
       aiturkMobile?: {
         open: () => Promise<{ ok: true }>
       }
+      /** "Codex Bağlama" (electron/codex-link.ts): lets the Codex on this machine
+       *  use the IDE's models. `get` only reads; `set` applies and returns the
+       *  state that actually resulted. Windows only. */
+      codexLink?: {
+        get: () => Promise<CodexLinkStatus>
+        set: (patch: CodexLinkPatch) => Promise<CodexLinkStatus>
+      }
       /** One-shot loopback callback listener for MCP OAuth against remote
        *  backends (electron/mcp-oauth-callback-ipc.ts): bind on THIS machine,
        *  pass redirectUri as client_redirect_uri to mcp.servers.oauth.start,

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

@@ -0,0 +1,80 @@
+import type { CodexLinkError } from '../../electron/codex-link-types'
+
+import { useI18n } from './context'
+
+// Copy for Settings → Codex Link ("Codex Bağlama"). Kept beside the other
+// AITURK-distribution strings (see ./aiturk): Turkish for `tr`, English for
+// every other locale.
+const en = {
+  nav: 'Codex Link',
+  title: 'Codex Link',
+  description:
+    'Adds the models and combos from AITURK IDE to the Codex on this computer and keeps the conversation context when you switch between models.',
+  unavailable: 'Codex Link is only available in the Windows desktop app.',
+  loadFailed: 'Could not read the Codex Link status.',
+  saveFailed: 'Could not change Codex Link.',
+  statusTitle: 'Status',
+  off: 'Codex Link is off. Codex runs with its own settings.',
+  codexFound: 'Codex was found on this computer.',
+  codexMissing: 'Codex was not found on this computer.',
+  foreign: 'Codex on this computer uses another bridge; its settings were not touched.',
+  venvPending: 'It will turn on once the IDE setup is complete.',
+  bridgeRunning: 'The bridge is running.',
+  bridgeStopped: 'The bridge is not running.',
+  models: (count: number) => (count === 1 ? '1 model added to Codex.' : `${count} models added to Codex.`),
+  signIn: 'No IDE session was found; sign in.',
+  errors: {
+    'autostart-failed': 'Could not set the bridge to start with Windows.',
+    'bridge-config-failed': 'Could not write the bridge settings.',
+    'bridge-missing': 'The bridge files are missing from this installation.',
+    'bridge-start-failed': 'The bridge could not be started; the Codex settings were left unchanged.',
+    'config-write-failed': 'Could not write the Codex settings file.',
+    'settings-write-failed': 'Could not save this setting.'
+  } satisfies Record<CodexLinkError, string>,
+  syncTitle: 'Sync now',
+  syncDesc: 'Checks the bridge and the Codex settings again.',
+  sync: 'Sync now',
+  syncing: 'Syncing…',
+  restartNote: 'Reopen Codex to see new models there.'
+}
+
+const tr: typeof en = {
+  nav: 'Codex Bağlama',
+  title: 'Codex Bağlama',
+  description:
+    "AITURK IDE'deki modelleri ve comboları bu bilgisayardaki Codex'e ekler; modeller arasında geçerken sohbet bağlamını korur.",
+  unavailable: 'Codex Bağlama yalnızca Windows masaüstü uygulamasında kullanılabilir.',
+  loadFailed: 'Codex Bağlama durumu okunamadı.',
+  saveFailed: 'Codex Bağlama değiştirilemedi.',
+  statusTitle: 'Durum',
+  off: 'Codex Bağlama kapalı. Codex kendi ayarlarıyla çalışıyor.',
+  codexFound: 'Bu bilgisayarda Codex bulundu.',
+  codexMissing: 'Bu bilgisayarda Codex bulunamadı.',
+  foreign: 'Bu bilgisayarda Codex başka bir köprü kullanıyor; ayarına dokunulmadı.',
+  venvPending: 'IDE kurulumu tamamlanınca etkinleşecek.',
+  bridgeRunning: 'Köprü çalışıyor.',
+  bridgeStopped: 'Köprü çalışmıyor.',
+  models: (count: number) => `Codex'e ${count} model eklendi.`,
+  signIn: 'IDE oturumu bulunamadı, giriş yapın.',
+  errors: {
+    'autostart-failed': 'Köprü Windows açılışında başlayacak şekilde ayarlanamadı.',
+    'bridge-config-failed': 'Köprü ayarları yazılamadı.',
+    'bridge-missing': 'Köprü dosyaları bu kurulumda bulunamadı.',
+    'bridge-start-failed': 'Köprü başlatılamadı; Codex ayarına dokunulmadı.',
+    'config-write-failed': 'Codex ayar dosyası yazılamadı.',
+    'settings-write-failed': 'Bu ayar kaydedilemedi.'
+  },
+  syncTitle: 'Şimdi eşitle',
+  syncDesc: 'Köprüyü ve Codex ayarını yeniden denetler.',
+  sync: 'Şimdi eşitle',
+  syncing: 'Eşitleniyor…',
+  restartNote: "Codex'te yeni modelleri görmek için Codex'i yeniden açın."
+}
+
+export type CodexLinkCopy = typeof en
+
+export function useCodexLinkCopy(): CodexLinkCopy {
+  const { locale } = useI18n()
+
+  return locale === 'tr' ? tr : en
+}

apps/desktop/vitest.mobile.config.ts

@@ -6,7 +6,8 @@ export default defineConfig({
     include: [
       'electron/mobile-*.test.ts',
       'electron/first-run-setup*.test.ts',
-      'electron/primary-backend-startup.test.ts'
+      'electron/primary-backend-startup.test.ts',
+      'electron/codex-link*.test.ts'
     ]
   }
 })

package-lock.json

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