systa-mcp 1.9.0 → 1.10.0

package/README.md

@@ -101,7 +101,7 @@ claude mcp add systa \
 
 ## Araçlar (tools)
 
-Toplam **90 araç** vardır; `tools/list` yanıtı anahtarın kapsamına göre filtrelenir
+Toplam **93 araç** vardır; `tools/list` yanıtı anahtarın kapsamına göre filtrelenir
 (bkz. "Scope-aware araç listesi"). Aşağıdakiler en sık kullanılan çekirdek araçlardır —
 tam katalog `list_capabilities` ile keşfedilir.
 
@@ -136,15 +136,20 @@ onu önler. Sıra: **bak → konuş → sahiplen → sinyal ver → bırak.**
 | `send_work_session_message`   | Birinin açık oturumuna yaz (kapalı oturum 409 döner) — `collaboration.message`            |
 | `send_room_message`           | Kaydın kendisine kalıcı not: `project` / `request` / `card` — `collaboration.message`     |
 | `read_messages`               | Konuşmayı oku; `afterId` ile "son okuduğumdan beri ne geldi"                              |
-| `listen_room`                 | Sınırlı süre canlı dinle (varsayılan 30 sn, en çok 120) — `work-session.view-active`      |
+| `listen_room`                 | Kısa süreli bloke dinleme (varsayılan 30 sn, en çok 240) — `work-session.view-active`     |
+| `subscribe_room`              | Arka planda dinlemeye başla, ANINDA dön — izleme kipi budur                               |
+| `drain_room_events`           | Aboneliklerde biriken olayları anında al (tamponu boşaltır, API'ye dokunmaz)              |
+| `unsubscribe_room`            | Aboneliği kapat; tamponda kalan olaylar son kez döner                                     |
 
 **Odaya katılma diye bir adım yoktur.** Oda abone olunan kanal değil, kaydın kendisidir;
 erişim kapsamın yetiyorsa okur ve yazarsın. Gantt ve k&k chart üzerindeki düğüm proje,
 talep ya da kart olabilir — mesaj düğümün **temsil ettiği şeyin** odasına gider.
 
 **Sürekli dinleme (monitor) kipi yoktur.** MCP istemcisine push gelmez. Bekliyorsan
-`listen_room`, çalışıyorsan uğrayış başına tek `read_messages(afterId)`. İkisini birden
-yapmak ya da `listen_room` çağrılarını zincirlemek turu boşa harcar.
+`listen_room` (en çok 240 sn — daha uzunu MCP istemcileri tarafından kesilir), çalışırken
+haberdar olmak istiyorsan `subscribe_room` + `drain_room_events` (arka planda dinler, hiçbir
+çağrı bloke olmaz, API yoklanmaz), sadece arada bir uğruyorsan uğrayış başına tek
+`read_messages(afterId)`. `listen_room` çağrılarını zincirlemek turu boşa harcar.
 
 `systa_api_call` ile, özel bir aracı olmayan herhangi bir endpoint çağrılabilir
 (örn. `POST /requests`, `POST /requests/42/comments`). Anahtarın scope'u dışındaki

package/SKILL.md

@@ -1,5 +1,5 @@
 ---
-version: 1.9.0
+version: 1.10.0
 name: systa
 description: |
   Drive SysTa (Talep Takip Sistemi / SysTa) — a
@@ -234,18 +234,25 @@ Gantt ve k&k chart üzerinde bir düğüm proje, talep ya da kart olabilir. Mesa
 
 SysTa'nın canlı kanalı bir yayın odasıdır ve ön yüzün dinlediği odanın **aynısıdır**: tarayıcıdaki kullanıcı hangi olayı görüyorsa sen de onu görürsün. Üç şeyi bilmen yeterli:
 
-1. **Katılma adımı yoktur.** `listen_room(roomType, roomId)` çağrısı kanalı açar ve abonelik o anda kurulur. Ayrı bir "odaya gir" çağrısı, üyelik kaydı ya da el sıkışma yoktur. Erişim kapsamın o kaydı görmene izin veriyorsa dinleyebilirsin; vermiyorsa çağrı boş sonuç değil **doğrudan ret** döner.
+1. **Katılma adımı yoktur.** `subscribe_room(roomType, roomId)` ya da `listen_room(roomType, roomId)` çağrısı kanalı açar ve abonelik o anda kurulur. Ayrı bir "odaya gir" çağrısı, üyelik kaydı ya da el sıkışma yoktur. Erişim kapsamın o kaydı görmene izin veriyorsa dinleyebilirsin; vermiyorsa çağrı boş sonuç değil **doğrudan ret** döner.
 2. **Olay mesajın KENDİSİNİ taşır.** Gelen olayın gövdesi `read_messages` ile aynı biçimdedir: gönderen, metin, kimlik, hepsi içindedir. Yani "bildirim geldi, şimdi içeriği çekeyim" diye **ikinci bir API çağrısı yapmana gerek yoktur**. Ek çağrı yalnız tek bir durumda gerekir: akış ortasında koparsa, `read_messages(afterId = gördüğün son id)` ile tam kaldığın yerden devam edersin.
 3. **Odada insan olmasa da duyarsın.** Agent kanalı sunucuda bilinçli olarak ayrı tutulur; "odada kimse yok" optimizasyonu senin yayınını kesmez. Gece yarısı tek başına çalışıyorsan da mesaj sana ulaşır.
 
-**Yeni mesajı nasıl alırsın: iki yol var, ikisini birden yapma.**
+**Yeni mesajı nasıl alırsın: üç yol var, hangisinde olduğunu bil.**
 
-Önce şunu bil: MCP istemcisine **push yoktur**. Arka planda çalışan bir abonelik, seni uyandıran bir olay yoktur. Ya beklersin ya dönüp sorarsın.
+Doğru soru şudur: **şu an bekliyor muyum, çalışırken haberdar mı olmak istiyorum, yoksa sadece arada bir uğruyor muyum?** Üçünün aracı ayrıdır ve birini diğerinin yerine kullanmak pahalıdır.
 
-1. **Bekliyorsan → `listen_room(roomType, roomId, seconds)`.** Bir soru sordun ve cevabı gelmeden devam edemiyorsun; ya da birinin dosyayı bırakmasını bekliyorsun. `listen_room` canlı kanalı açar, **sınırlı süre** bekler (varsayılan 30 saniye, en çok bir saat) ve o sırada geleni döndürür. Sunucu kanalı süresiz açık tutar ve 25 saniyede bir keepalive gönderir; yani tavanı belirleyen sunucunun sabrı değil **senin turun**: bu çağrı açıkken dosya düzenleyemez, derleme çalıştıramaz, başka araç çağıramazsın. Süreyi beklediğin şeye göre seç — cevabı hemen gereken bir soru için yarım dakika, bilinçli olarak dinleyici modunda durduğun bir oda için dakikalar ya da saat. `stoppedBy` neden döndüğünü söyler: `timeout` | `maxEvents` | `streamEnded`. Beklemeye devam etmek için yeniden çağırırsın.
-2. **Çalışıyorsan → `read_messages(..., afterId)`.** Yapacak işin var, sadece sen meşgulken ne olduğunu öğrenmek istiyorsun. Her uğrayışta **tek çağrı**, döngü değil. Uğrayışlar arasında asıl işini yap.
+1. **Çalışırken haberdar olmak istiyorsan → `subscribe_room` + `drain_room_events`.** Asıl kip budur ve 1.10.0 ile geldi. `subscribe_room(roomType, roomId)` odanın canlı kanalını **arka planda** açar ve **anında döner** — beklemez, turunu bloke etmez, bir araç çağrısını açık tutmaz. Sen kendi işini yaparsın (dosya düzenler, derleme çalıştırır, kart taşırsın); gelen olaylar bir tamponda birikir. Adımlar arasında `drain_room_events` çağırırsın: o da **anında döner** ve son çağrıdan beri ne geldiyse verir. İş bitince `unsubscribe_room` ya da hiç: abonelikler süreçle birlikte ölür.
 
-**Sürekli dinleme (monitor) diye bir kip yoktur.** `listen_room` çağrılarını arka arkaya zincirleyip odayı "izlemeye almak" turunu boşa harcar: bir saat sessiz kalan oda sana kırk kez boş sonuç döndürür. Aynı şekilde `read_messages`'ı sıkı döngüde çağırmak da yanlış cevaptır. Doğru soru şudur: **şu an bekliyor muyum, yoksa çalışıyor muyum?**
+   **Bu yoklamak değildir.** API'ye "yeni bir şey var mı?" diye tekrar tekrar sormuyorsun. Tek bir canlı kanal açık durur ve olayları sana iter; `drain_room_events` yalnız yerel tamponu okur, API'ye hiç dokunmaz. On kez boşaltmak bir kez boşaltmakla aynı maliyettedir.
+
+2. **Şu anda bekliyorsan → `listen_room(roomType, roomId, seconds)`.** Bir soru sordun, cevabı gelmeden devam edemiyorsun ve cevabı dakikalar içinde bekliyorsun. Bu çağrı açıkken dosya düzenleyemez, derleme çalıştıramaz, başka araç çağıramazsın. Tavan **240 saniyedir** — ve bu keyfi değil: çağrı açıkken MCP istemcisine **tek bayt akmaz** (kanal canlılık sinyali SysTa ile MCP sunucusu arasındadır, istemci onu görmez), istemci de sessiz çağrıyı askıda sayıp keser. Ölçüldü 2026-09-11: bir Codex istemcisi 3300 saniyelik beklemeyi **altıncı dakikada** `terminated` ile kapattı. Eskiden yazan "en çok bir saat" ifadesi hiçbir istemcide çalışmıyordu. Birkaç dakikadan uzun her şey için 1. maddeyi kullan.
+
+3. **Sadece arada bir uğruyorsan → `read_messages(..., afterId)`.** Aboneliğin yok ve geçmişe bakıyorsun. Her uğrayışta **tek çağrı**, döngü değil.
+
+**Zincirleme yapma.** `listen_room` çağrılarını arka arkaya dizip odayı "izlemeye almak" turunu boşa harcar ve zaten istemci tarafından kesilir; `read_messages`'ı sıkı döngüde çağırmak da yanlış cevaptır. İzleme kipi artık gerçekten vardır ve adı `subscribe_room`'dur.
+
+**Abonelikte kayıp SESSİZ DEĞİLDİR.** Aynı anda en çok 10 oda, oda başına en çok 200 olay tamponlanır. Tampon taşarsa **en eski** olay düşer ve `dropped` bunu sayar. Kanal koparsa kendiliğinden yeniden bağlanır ve `reconnects` artar. Her iki durumda da sonuç `gapSinceLastEventId` taşır: `read_messages(roomType, roomId, afterId = o değer)` ile aralığı tam olarak kapatırsın. `status` aboneliğin nerede olduğunu söyler (`live` | `connecting` | `reconnecting` | `closed`); kapanmışsa `closedReason` sebebini verir (`idleTimeout` — 30 dakika boşaltılmadı, `maxLifetime` — 4 saat doldu, `refused` — erişimin yok, `unsubscribed`, `error`). Yeniden gerekiyorsa yeniden abone ol.
 
 **İmleç.** `afterId` = okuduğun son mesajın kimliği; yalnız ondan sonrakileri alırsın. **Zaman damgasını imleç olarak kullanma** — API milisaniye yazar, kolon mikrosaniye tutar ve aynı satır iki kez gelir (ölçüldü 2026-09-08); yanıttaki `pagination.nextAfterId` alanını kullan. İlk çağrıyı imleçsiz yap, yakın geçmişi al, `nextAfterId` değerini sakla ve bundan sonra onu kullan.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "systa-mcp",
-  "version": "1.9.0",
+  "version": "1.10.0",
   "description": "MCP stdio server for SysTa (Talep Takip Sistemi) — lets AI agents (Claude, Codex) use the SysTa REST API via a scoped API key. Zero npm dependencies (native Node).",
   "type": "commonjs",
   "main": "server.js",

package/server.js

@@ -1357,6 +1357,250 @@ const MODULE_GATE_NOTE =
   'NOT an invalid key and NOT a missing permission -- do not tell the user to regenerate the ' +
   'key; tell them to have the vendor administrator enable API/MCP access.';
 
+// ── Arka plan oda aboneligi (1.10.0) ─────────────────────────────────────────
+//
+// NEDEN VAR. `listen_room` bir MCP `tools/call` cagrisini bekleme suresince
+// ACIK TUTAR. Bekleme boyunca kanaldan istemciye tek bayt akmaz, cunku
+// keepalive SysTa ile MCP sunucusu arasindaki SSE kanalindadir — istemci onu
+// GORMEZ. Istemcinin kendi istek zaman asimi devreye girer ve cagriyi
+// `terminated` ile keser. Olculdu 2026-09-11: Codex CLI, 3300 saniyelik bir
+// beklemeyi altinci dakikada kesti. Sunucu tarafinda kusur yoktu; istemci
+// beklemeyi askida kalmis sayiyor.
+//
+// COZUM. Beklemeyi cagrinin ICINDEN cikarmak. `subscribe_room` arka planda SSE
+// baglantisini acar ve ANINDA doner; olaylar bu surecte bir tamponda birikir;
+// `drain_room_events` tamponu ANINDA bosaltir. Ajanin turu hicbir noktada
+// bloke olmaz, API surekli yoklanmaz (bekleme isini yine SSE yapar) ve
+// istemcinin zaman asimi devreye giremez, cunku hicbir cagri uzun surmez.
+//
+// SINIRLAR ACIKTIR VE SESSIZ DEGILDIR. Tampon dolarsa EN ESKI olay dusurulur ve
+// `dropped` sayaci artar; ajan bunu gorup `read_messages(afterId)` ile telafi
+// eder. Baglanti koparsa dongu kendiliginden yeniden baglanir, `reconnects`
+// artar ve `gapSinceLastEventId` verilir — o aralik icin yine `read_messages`
+// dogru aractir.
+const ABONE_ODA_TAVANI = 10;
+const ABONE_TAMPON_TAVANI = 200;
+// Ajan tamponu bu kadar sure hic bosaltmazsa abonelik kendini kapatir. Amac
+// unutulmus aboneliklerin sonsuza kadar acik kalmamasi; sure uzun tutuldu,
+// cunku ajan uzun bir derleme ya da test kosumu sirasinda mesru olarak
+// sessiz kalabilir.
+const ABONE_BOSTA_MS = 30 * 60 * 1000;
+const ABONE_MUTLAK_OMUR_MS = 4 * 60 * 60 * 1000;
+const ABONE_BACKOFF_MS = [1000, 2000, 4000, 8000, 15000];
+
+/** @type {Map<string, object>} */
+const ABONELIKLER = new Map();
+
+const aboneAnahtari = (roomType, roomId) => `${roomType}:${roomId}`;
+
+const bekle = (ms) =>
+  new Promise((resolve) => {
+    const t = setTimeout(resolve, ms);
+    // Bekleme SURECI AYAKTA TUTMASIN: stdin kapandiginda surec cikabilmeli.
+    if (typeof t.unref === 'function') {
+      t.unref();
+    }
+  });
+
+/**
+ * Bir olayin tasidigi mesaj kimligini bulur (varsa). Kopukluk sonrasi
+ * `read_messages(afterId)` icin baslangic noktasi budur.
+ * @param {object} olay - parseSseRecord ciktisi
+ * @returns {number|null}
+ */
+const olayMesajKimligi = (olay) => {
+  const veri = olay && olay.data;
+  if (!veri || typeof veri !== 'object') {
+    return null;
+  }
+  const aday = veri.id ?? veri.messageId ?? (veri.message && veri.message.id);
+  const sayi = Number(aday);
+  return Number.isFinite(sayi) ? sayi : null;
+};
+
+/**
+ * SSE tamponundaki TAM kayitlari olaya cevirip abonelige yazar; yarim kalan
+ * son parcayi geri dondurur (bir sonraki parcayla birlesecek).
+ * @param {object} abone
+ * @param {string} tampon
+ * @returns {string} islenmemis kalan
+ */
+const sseTamponunuIsle = (abone, tampon) => {
+  let kalan = tampon;
+  let index = kalan.indexOf('\n\n');
+  while (index !== -1) {
+    const olay = parseSseRecord(kalan.slice(0, index));
+    kalan = kalan.slice(index + 2);
+    if (olay !== null) {
+      aboneyeYaz(abone, olay);
+    }
+    index = kalan.indexOf('\n\n');
+  }
+  return kalan;
+};
+
+/**
+ * Aboneligin SSE baglantisini acar. Yetki/erisim reddinde aboneligi KAPATIR:
+ * 401/403/404 yeniden denemeyle duzelmez ve sessizce yeniden denemek, ajanin
+ * odayi dinledigini SANMASINA yol acardi.
+ * @param {object} abone
+ * @param {AbortController} controller
+ * @returns {Promise<Response|null>} akis yanitı; null = bu turda acilamadi
+ */
+const aboneAkisiniAc = async (abone, controller) => {
+  const headers = { Authorization: `Bearer ${API_KEY}`, Accept: 'text/event-stream' };
+  if (VENDOR_CODE) {
+    headers['X-Vendor-Code'] = VENDOR_CODE;
+  }
+  const response = await fetch(new URL(BASE_URL + abone.apiPath), {
+    method: 'GET',
+    headers,
+    signal: controller.signal,
+  });
+  if (response.ok) {
+    return response;
+  }
+  const text = await response.text();
+  if (response.status === 401 || response.status === 403 || response.status === 404) {
+    abone.lastError = `HTTP ${response.status}: ${text.slice(0, 200)}`;
+    abone.closedReason = 'refused';
+    return null;
+  }
+  abone.lastError = `HTTP ${response.status}`;
+  throw new Error(abone.lastError);
+};
+
+/**
+ * Aboneligin arka plan dongusu: SSE'yi acar, olaylari tampona yazar, kopukta
+ * artan gecikmeyle yeniden baglanir. `abone.kapali` true olunca sona erer.
+ * @param {object} abone
+ * @returns {Promise<void>}
+ */
+const aboneDongusu = async (abone) => {
+  let backoffIndex = 0;
+  while (!abone.kapali) {
+    if (Date.now() - abone.startedAt > ABONE_MUTLAK_OMUR_MS) {
+      abone.closedReason = 'maxLifetime';
+      break;
+    }
+    const controller = new AbortController();
+    abone.controller = controller;
+    try {
+      const response = await aboneAkisiniAc(abone, controller);
+      if (response === null) {
+        break;
+      }
+      abone.status = 'live';
+      abone.lastError = null;
+      backoffIndex = 0;
+      const decoder = new TextDecoder();
+      let tampon = '';
+      for await (const chunk of response.body) {
+        tampon = sseTamponunuIsle(abone, tampon + decoder.decode(chunk, { stream: true }));
+      }
+    } catch (error) {
+      if (abone.kapali) {
+        break;
+      }
+      if (error.name !== 'AbortError') {
+        abone.lastError = error.message;
+      }
+    }
+    if (abone.kapali || abone.closedReason) {
+      break;
+    }
+    // Akis normal bitse de kopsa da yeniden baglaniriz; fark yalniz gecikmede.
+    abone.reconnects += 1;
+    abone.status = 'reconnecting';
+    await bekle(ABONE_BACKOFF_MS[Math.min(backoffIndex, ABONE_BACKOFF_MS.length - 1)]);
+    backoffIndex += 1;
+  }
+  abone.status = 'closed';
+  abone.kapali = true;
+  if (!abone.closedReason) {
+    abone.closedReason = 'unsubscribed';
+  }
+};
+
+/**
+ * Olayi aboneligin halka tamponuna yazar. Tampon doluysa EN ESKI olay dusurulur
+ * ve sayac artar — sessiz kayip yok.
+ * @param {object} abone
+ * @param {object} olay
+ */
+const aboneyeYaz = (abone, olay) => {
+  const kimlik = olayMesajKimligi(olay);
+  if (kimlik !== null) {
+    abone.lastEventId = kimlik;
+  }
+  abone.events.push(olay);
+  abone.totalEvents += 1;
+  while (abone.events.length > ABONE_TAMPON_TAVANI) {
+    abone.events.shift();
+    abone.dropped += 1;
+  }
+};
+
+/**
+ * Bosta kalmis ya da omrunu doldurmus abonelikleri kapatir. Her abonelik
+ * cagrisinda calisir; ayri bir zamanlayici YOK (zamanlayici sureci ayakta
+ * tutardi).
+ */
+const aboneleriSupur = () => {
+  const simdi = Date.now();
+  for (const abone of ABONELIKLER.values()) {
+    if (abone.kapali) {
+      continue;
+    }
+    const bosta = simdi - (abone.lastDrainAt || abone.startedAt);
+    if (bosta > ABONE_BOSTA_MS) {
+      abone.closedReason = 'idleTimeout';
+      aboneKapat(abone);
+    } else if (simdi - abone.startedAt > ABONE_MUTLAK_OMUR_MS) {
+      abone.closedReason = 'maxLifetime';
+      aboneKapat(abone);
+    }
+  }
+};
+
+/**
+ * Aboneligi kapatir: dongu bir sonraki adimda sonlanir, acik SSE istegi hemen
+ * iptal edilir.
+ * @param {object} abone
+ */
+const aboneKapat = (abone) => {
+  abone.kapali = true;
+  abone.status = 'closed';
+  if (abone.controller) {
+    try {
+      abone.controller.abort();
+    } catch {
+      // Zaten kapanmis baglantiyi iptal etmek hata degildir.
+    }
+  }
+};
+
+/**
+ * Aboneligin ajana gosterilen ozeti. Tampon ICERIGI burada YOK — olaylari
+ * yalniz `drain_room_events` verir ve verdikten sonra tamponu bosaltir.
+ * @param {object} abone
+ * @returns {object}
+ */
+const aboneOzeti = (abone) => ({
+  roomType: abone.roomType,
+  roomId: abone.roomId,
+  status: abone.status,
+  pending: abone.events.length,
+  totalEvents: abone.totalEvents,
+  dropped: abone.dropped,
+  reconnects: abone.reconnects,
+  lastEventId: abone.lastEventId,
+  startedAt: new Date(abone.startedAt).toISOString(),
+  lastDrainAt: abone.lastDrainAt ? new Date(abone.lastDrainAt).toISOString() : null,
+  lastError: abone.lastError,
+  closedReason: abone.closedReason,
+});
+
 const TOOLS = [
   {
     name: 'list_requests',
@@ -2404,7 +2648,7 @@ WAITING FOR THE ANSWER. A session message does not notify you back. If you canno
 
 Reading needs "work-session.view-active"; WRITING needs "collaboration.message". Seeing coordination and joining it are separate privileges.
 
-Body is plain text, at most 2000 characters. Trailing and leading spaces are trimmed; an empty body is refused.`,
+Body is plain text, at most 4000 characters. Trailing and leading spaces are trimmed; an empty body is refused.`,
     inputSchema: {
       type: 'object',
       additionalProperties: false,
@@ -2414,7 +2658,7 @@ Body is plain text, at most 2000 characters. Trailing and leading spaces are tri
           type: 'integer',
           description: 'Open work session id — read it from list_active_work_sessions.',
         },
-        body: { type: 'string', description: 'Plain text, 1..2000 characters.' },
+        body: { type: 'string', description: 'Plain text, 1..4000 characters.' },
       },
     },
     handler: (args) =>
@@ -2439,7 +2683,7 @@ ROOM OR SESSION. The message is about the record -> room. The message is about s
 
 Requires "collaboration.message". Reading is a weaker privilege than writing: a role may watch coordination without joining it.
 
-Body is plain text, at most 2000 characters.`,
+Body is plain text, at most 4000 characters.`,
     inputSchema: {
       type: 'object',
       additionalProperties: false,
@@ -2447,7 +2691,7 @@ Body is plain text, at most 2000 characters.`,
       properties: {
         roomType: { type: 'string', enum: ['project', 'request', 'card'] },
         roomId: { type: 'integer', description: 'Project id, request number, or card GLOBAL id.' },
-        body: { type: 'string', description: 'Plain text, 1..2000 characters.' },
+        body: { type: 'string', description: 'Plain text, 1..4000 characters.' },
       },
     },
     handler: (args) =>
@@ -2512,19 +2756,20 @@ FIRST CALL: read once with no cursor to get the recent history, remember paginat
     name: 'listen_room',
     description: `Wait for live activity in a room instead of polling. Opens the live channel, listens for a bounded time, and returns whatever arrived.
 
-THIS IS A BOUNDED WAIT, NOT A SUBSCRIPTION. It returns after "seconds" (default 30, max 3600 = one hour), or earlier once maxEvents is reached. It does not keep running in the background and nothing is delivered to you afterwards. stoppedBy tells you why it returned: timeout | maxEvents | streamEnded. To keep waiting, call it again.
+THIS IS A BOUNDED WAIT, NOT A SUBSCRIPTION. It returns after "seconds" (default 30, max 240 = four minutes), or earlier once maxEvents is reached. It does not keep running in the background and nothing is delivered to you afterwards. stoppedBy tells you why it returned: timeout | maxEvents | streamEnded. To keep waiting, call it again.
 
-HOW LONG SHOULD YOU WAIT. The server keeps the channel open indefinitely (it sends a keepalive every 25 seconds), so the ceiling here is about YOUR turn, not the server's patience. While this call is open your turn is blocked: you cannot edit a file, run a build or call another tool. So pick the wait from what you are waiting for:
-  * a colleague is mid-sentence and you need the reply now -> 30 to 120 seconds
-  * you asked a question and have nothing else to do until it is answered -> a few minutes
-  * you are deliberately standing by as a listener on a shared room -> minutes to an hour
-Waiting an hour when you had work to do is the expensive mistake, not the long ceiling itself. If you have work, do the work and check back with read_messages(afterId) instead.
+WHY THE CEILING IS FOUR MINUTES AND NOT LONGER. While this call is open, NOTHING travels to your MCP client — the channel keepalive runs between the SysTa server and this MCP server, and your client cannot see it. Clients treat a silent call as hung and abort it. Measured 2026-09-11: a Codex CLI client killed a 3300-second wait in the sixth minute with "terminated". The old one-hour ceiling therefore worked on no client at all; it only produced aborted calls. If you need to watch a room for longer than a few minutes, listen_room is the WRONG tool — use subscribe_room.
 
-Note that your own MCP client may abort a tool call before the server does; if a long wait comes back early, that is the client's limit, not an error.
+FOR ANYTHING LONGER, USE subscribe_room. subscribe_room opens the channel in the background and returns instantly; drain_room_events then hands you whatever arrived, also instantly. Your turn is never blocked, no call is ever long enough to be aborted, and the API is not polled. That is the monitoring mode; this tool is not.
 
-WHEN TO USE IT. You are blocked on an answer: you asked somebody with send_work_session_message or send_room_message and cannot continue until they reply. Or you are waiting for a colleague to release a file. In both cases you have nothing useful to do meanwhile, so waiting inside one call is cheaper and faster than repeated reads.
+HOW LONG SHOULD YOU WAIT HERE. While this call is open your turn is blocked: you cannot edit a file, run a build or call another tool. So pick the wait from what you are waiting for:
+  * a colleague is mid-sentence and you need the reply now -> 30 to 120 seconds
+  * you asked a question and have nothing else to do until it is answered -> up to the 240 ceiling
+  * anything longer, or anything you want to watch WHILE working -> subscribe_room
+
+WHEN TO USE IT. You are blocked on an answer right now: you asked somebody with send_work_session_message or send_room_message and cannot continue until they reply, and you expect the reply within minutes. You have nothing useful to do meanwhile, so one short wait beats repeated reads.
 
-WHEN NOT TO USE IT. You have work to do. Then do the work and check in afterwards with read_messages(afterId). Chaining listen_room calls back to back to "monitor" a room burns your turn for nothing — there is no monitoring mode, and a room that is quiet for an hour returns you an empty result forty times.
+WHEN NOT TO USE IT. You have work to do. Then subscribe_room, do the work, and drain_room_events between steps. Chaining listen_room calls back to back to "monitor" a room burns your turn for nothing.
 
 HOW THE CHANNEL WORKS (you cannot read the code, so here it is). The live channel is a broadcast room and it is the SAME room the web UI listens to: whatever a person in the browser sees, you see. Three facts:
   * There is no join step. This call opens the channel and the subscription is created right then. No separate "enter room" call, no membership record, no handshake.
@@ -2544,7 +2789,7 @@ Requires "work-session.view-active". You only reach rooms your access scope alre
         seconds: {
           type: 'integer',
           description:
-            'How long to wait before returning, default 30, max 3600 (one hour). Your turn is blocked for this whole time, so match it to what you are waiting for.',
+            'How long to wait before returning, default 30, max 240 (four minutes). Your turn is blocked for this whole time. Longer waits are aborted by MCP clients, so for anything longer use subscribe_room instead.',
         },
         maxEvents: {
           type: 'integer',
@@ -2558,11 +2803,243 @@ Requires "work-session.view-active". You only reach rooms your access scope alre
         {
           // Tavan bir SAAT. Sunucu akisi suresiz acik tutar (25 sn'de bir
           // keepalive), yani sinir sunucunun sabri degil ajanin turudur.
-          seconds: Math.min(Number(args.seconds) || 30, 3600),
+          // Tavan 240 SANIYE. Sunucu akisi suresiz acik tutabilir, ama MCP
+          // ISTEMCISI sessiz gecen bir cagriyi askida sayip keser: olculdu
+          // 2026-09-11, Codex CLI 3300 saniyelik beklemeyi altinci dakikada
+          // `terminated` ile kapatti. Hicbir istemcide calismayan bir saatlik
+          // tavan yaniltici oldugu icin gercekci bir degere cekildi. Daha
+          // uzun dinleme icin doğru arac subscribe_room + drain_room_events.
+          seconds: Math.min(Number(args.seconds) || 30, 240),
           maxEvents: Math.min(Number(args.maxEvents) || 50, 200),
         },
       ),
   },
+  {
+    name: 'subscribe_room',
+    description: `Start listening to a room IN THE BACKGROUND and return immediately. This is the monitoring mode listen_room does not have.
+
+WHAT IT DOES. It opens the room's live channel inside this MCP server process and keeps it open. Events that arrive are buffered for you. The call itself returns at once — it does NOT wait, it does NOT block your turn, and it does NOT hold a tool call open. You then go do your own work (edit files, run builds, move cards) and call drain_room_events whenever you want to see what arrived. The waiting is done by the open channel, not by you.
+
+WHY THIS EXISTS. listen_room holds one tool call open for the whole wait. During that wait nothing travels to your MCP client, so your client's own request timeout can fire and abort the call ("terminated") long before the wait is over. Measured 2026-09-11: a Codex CLI client killed a 3300-second wait in the sixth minute. Nothing was broken server-side — the client simply treats a silent call as hung. subscribe_room removes that failure mode entirely, because no call is ever long.
+
+THIS IS NOT POLLING. You are not asking the API "anything new?" over and over. One live channel stays open and pushes events to this process; drain_room_events reads a local buffer and never touches the API. Ten drains cost the same as one.
+
+TYPICAL SHAPE OF A SESSION:
+  1. subscribe_room for each room you care about (your request room, the cards you are working on)
+  2. do your actual work
+  3. drain_room_events between steps — it returns instantly whether or not anything arrived
+  4. unsubscribe_room when you are done, or just end your session (subscriptions die with the process)
+
+LIMITS ARE VISIBLE, NEVER SILENT. At most 10 rooms at once and 200 buffered events per room. If the buffer overflows the OLDEST event is dropped and "dropped" counts it, so you know to recover with read_messages(afterId=lastEventId). If the channel drops it reconnects on its own and "reconnects" counts it; the same recovery applies to the gap. A subscription closes itself after 30 minutes with no drain, or 4 hours total, and says so in closedReason.
+
+Same room, same access rules and same event shape as listen_room and read_messages. Subscribing twice to one room is not an error; it returns the existing subscription untouched.
+
+Requires "work-session.view-active". You only reach rooms your access scope already allows.`,
+    inputSchema: {
+      type: 'object',
+      additionalProperties: false,
+      required: ['roomType', 'roomId'],
+      properties: {
+        roomType: { type: 'string', enum: ['project', 'request', 'card'] },
+        roomId: { type: 'integer', description: 'Project id, request number, or card GLOBAL id.' },
+      },
+    },
+    handler: async (args) => {
+      if (!BASE_URL || !API_KEY) {
+        throw new Error('SYSTA_API_BASE_URL / SYSTA_API_KEY is not configured');
+      }
+      aboneleriSupur();
+      const anahtar = aboneAnahtari(args.roomType, args.roomId);
+      const mevcut = ABONELIKLER.get(anahtar);
+      if (mevcut && !mevcut.kapali) {
+        return {
+          status: 200,
+          ok: true,
+          data: { subscription: aboneOzeti(mevcut), alreadySubscribed: true },
+        };
+      }
+      const canli = [...ABONELIKLER.values()].filter((a) => !a.kapali);
+      if (canli.length >= ABONE_ODA_TAVANI) {
+        return {
+          status: 429,
+          ok: false,
+          data: {
+            error: 'TOO_MANY_SUBSCRIPTIONS',
+            message: `At most ${ABONE_ODA_TAVANI} rooms at once. Call unsubscribe_room on a room you no longer need.`,
+            subscriptions: canli.map(aboneOzeti),
+          },
+        };
+      }
+      const abone = {
+        roomType: args.roomType,
+        roomId: args.roomId,
+        apiPath: `/rooms/${encodeURIComponent(args.roomType)}/${encodeURIComponent(args.roomId)}/stream`,
+        events: [],
+        dropped: 0,
+        totalEvents: 0,
+        reconnects: 0,
+        lastEventId: null,
+        startedAt: Date.now(),
+        lastDrainAt: null,
+        status: 'connecting',
+        lastError: null,
+        closedReason: null,
+        kapali: false,
+        controller: null,
+      };
+      ABONELIKLER.set(anahtar, abone);
+      // Fire-and-forget: dongu kendi hatasini abonelige yazar, sureci dusurmez.
+      aboneDongusu(abone).catch((error) => {
+        abone.lastError = error.message;
+        abone.status = 'closed';
+        abone.kapali = true;
+        abone.closedReason = 'error';
+      });
+      return {
+        status: 200,
+        ok: true,
+        data: {
+          subscription: aboneOzeti(abone),
+          alreadySubscribed: false,
+          note: 'Listening in the background. Do your work, then call drain_room_events — it returns instantly.',
+        },
+      };
+    },
+  },
+  {
+    name: 'drain_room_events',
+    description: `Take everything that arrived on your background subscriptions since the last drain. Returns INSTANTLY — it never waits and never calls the API.
+
+This is the read half of subscribe_room. The buffer is emptied by this call, so each event is handed to you exactly once. An empty result genuinely means nobody said anything; it does not mean the channel is broken (check "status" if unsure).
+
+Call it freely. It is a local buffer read, so draining ten times between build steps costs nothing. This is the correct way to stay aware of a room while you work — not chained listen_room calls, and not repeated read_messages.
+
+WITHOUT ARGUMENTS it drains every room you are subscribed to. Give roomType+roomId to drain just one.
+
+EVENTS CARRY THE MESSAGE ITSELF — same shape as read_messages, sender and text included. You do NOT need a second call to fetch the content.
+
+WHEN YOU MUST RECOVER. Two fields tell you that you may have missed something:
+  * dropped > 0 — the buffer overflowed (more than 200 events between drains). 
+  * reconnects went up and the result carries gapSinceLastEventId — the channel dropped and came back.
+In both cases call read_messages(roomType, roomId, afterId = lastEventId) to fill the gap exactly. Nothing is silently lost; you are always told.
+
+status tells you where the subscription stands: live | connecting | reconnecting | closed. A closed subscription carries closedReason (idleTimeout | maxLifetime | refused | unsubscribed | error) — subscribe again if you still need it.`,
+    inputSchema: {
+      type: 'object',
+      additionalProperties: false,
+      properties: {
+        roomType: { type: 'string', enum: ['project', 'request', 'card'] },
+        roomId: { type: 'integer', description: 'Project id, request number, or card GLOBAL id.' },
+      },
+    },
+    handler: async (args) => {
+      aboneleriSupur();
+      if ((args.roomType && !args.roomId) || (!args.roomType && args.roomId)) {
+        throw new Error('Give both roomType and roomId, or neither (drains every subscription)');
+      }
+      const hedefler = args.roomType
+        ? [ABONELIKLER.get(aboneAnahtari(args.roomType, args.roomId))].filter(Boolean)
+        : [...ABONELIKLER.values()];
+      if (args.roomType && hedefler.length === 0) {
+        return {
+          status: 404,
+          ok: false,
+          data: {
+            error: 'NOT_SUBSCRIBED',
+            message: `No subscription for ${args.roomType}:${args.roomId}. Call subscribe_room first.`,
+          },
+        };
+      }
+      const simdi = Date.now();
+      const rooms = hedefler.map((abone) => {
+        const events = abone.events;
+        const dropped = abone.dropped;
+        const oncekiReconnects = abone.drainedReconnects || 0;
+        abone.events = [];
+        abone.dropped = 0;
+        abone.drainedReconnects = abone.reconnects;
+        abone.lastDrainAt = simdi;
+        const kopukluk = abone.reconnects > oncekiReconnects;
+        return {
+          roomType: abone.roomType,
+          roomId: abone.roomId,
+          status: abone.status,
+          events,
+          dropped,
+          reconnects: abone.reconnects,
+          lastEventId: abone.lastEventId,
+          // Kopukluk ya da tasma varsa aralik AYNEN soylenir; ajan bunu
+          // read_messages(afterId) ile kapatir.
+          gapSinceLastEventId: kopukluk || dropped > 0 ? abone.lastEventId : null,
+          lastError: abone.lastError,
+          closedReason: abone.closedReason,
+        };
+      });
+      // Kapanmis ve bosaltilmis abonelikler haritada tutulmaz.
+      for (const abone of hedefler) {
+        if (abone.kapali && abone.events.length === 0) {
+          ABONELIKLER.delete(aboneAnahtari(abone.roomType, abone.roomId));
+        }
+      }
+      return {
+        status: 200,
+        ok: true,
+        data: {
+          rooms,
+          totalEvents: rooms.reduce((toplam, oda) => toplam + oda.events.length, 0),
+        },
+      };
+    },
+  },
+  {
+    name: 'unsubscribe_room',
+    description: `Stop a background subscription started with subscribe_room and close its channel. Any events still buffered are returned one last time, so ending a subscription never loses what already arrived.
+
+Without arguments it stops EVERY subscription. Give roomType+roomId to stop just one.
+
+You do not have to call this before ending your session — subscriptions live inside this MCP server process and die with it. Use it when you are done with a room but still working, especially if you want to free a slot (10 rooms maximum).`,
+    inputSchema: {
+      type: 'object',
+      additionalProperties: false,
+      properties: {
+        roomType: { type: 'string', enum: ['project', 'request', 'card'] },
+        roomId: { type: 'integer', description: 'Project id, request number, or card GLOBAL id.' },
+      },
+    },
+    handler: async (args) => {
+      if ((args.roomType && !args.roomId) || (!args.roomType && args.roomId)) {
+        throw new Error('Give both roomType and roomId, or neither (stops every subscription)');
+      }
+      const hedefler = args.roomType
+        ? [ABONELIKLER.get(aboneAnahtari(args.roomType, args.roomId))].filter(Boolean)
+        : [...ABONELIKLER.values()];
+      if (args.roomType && hedefler.length === 0) {
+        return {
+          status: 404,
+          ok: false,
+          data: {
+            error: 'NOT_SUBSCRIBED',
+            message: `No subscription for ${args.roomType}:${args.roomId}.`,
+          },
+        };
+      }
+      const closed = hedefler.map((abone) => {
+        abone.closedReason = 'unsubscribed';
+        aboneKapat(abone);
+        const events = abone.events;
+        abone.events = [];
+        ABONELIKLER.delete(aboneAnahtari(abone.roomType, abone.roomId));
+        return {
+          roomType: abone.roomType,
+          roomId: abone.roomId,
+          finalEvents: events,
+          dropped: abone.dropped,
+          lastEventId: abone.lastEventId,
+        };
+      });
+      return { status: 200, ok: true, data: { closed } };
+    },
+  },
   {
     name: 'list_allowed_transitions',
     description: