@futdevpro/ccap 1.1.2654 → 1.1.2678

package/server/build/src/_modules/external-sessions/_modules/claude-code/_services/core/terminal/cc-adapter-terminal.control-service.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CC_AdapterTerminal_ControlService = void 0;
 const tslib_1 = require("tslib");
-const child_process_1 = require("child_process");
 const fs = tslib_1.__importStar(require("fs"));
 const path = tslib_1.__importStar(require("path"));
 const crypto_1 = require("crypto");
@@ -12,19 +11,17 @@ const ccap_error_control_model_1 = require("../../../../../../../_collections/co
 const version_const_1 = require("../../../../../../../_collections/core/version.const");
 const eh_record_build_util_1 = require("../../../../../../ccap-agent/_modules/error-handling/_collections/utils/eh-record-build.util");
 const ac_exec_terminal_window_status_enum_1 = require("../../../../../../ccap-agent/_modules/agent-core/_enums/ac-exec-terminal-window-status.enum");
-const attach_mandatory_child_process_error_handler_util_1 = require("../../../../../../ccap-agent/_modules/tools/_collections/utils/exec/attach-mandatory-child-process-error-handler.util");
-const get_windows_cmd_spawn_candidate_paths_util_1 = require("../../../../../../ccap-agent/_modules/tools/_collections/utils/exec/get-windows-cmd-spawn-candidate-paths.util");
 const instance_id_service_1 = require("../../../../../_services/instance-id.service");
 const cc_status_enum_1 = require("../../../_enums/cc-status.enum");
 const cc_cli_args_util_1 = require("../../../_collections/utils/cc-cli-args.util");
 const cc_process_exit_util_1 = require("../../../_collections/utils/lifecycle/cc-process-exit.util");
 const cc_kill_reasons_const_1 = require("../../../_collections/consts/cc-kill-reasons.const");
-const tls_linux_terminal_spawn_util_1 = require("../../../../../../ccap-agent/_modules/tools/_collections/utils/exec/tls-linux-terminal-spawn.util");
 const sq_session_type_enum_1 = require("../../../../../../session-queue/_enums/sq-session-type.enum");
 const session_queue_control_service_1 = require("../../../../../../session-queue/_services/control-services/session-queue.control-service");
 const claude_code_data_service_1 = require("../claude-code.data-service");
 const cc_terminal_data_service_1 = require("./cc-terminal.data-service");
 const cc_terminal_lifecycle_control_service_1 = require("./cc-terminal-lifecycle.control-service");
+const cc_terminal_runner_spawn_util_1 = require("./cc-terminal-runner-spawn.util");
 /**
  * CC Session terminal mode adapter (singleton).
  * Minden terminál-specifikus funkció: Socket.IO namespace, runner spawn,
@@ -93,6 +90,19 @@ class CC_AdapterTerminal_ControlService extends nts_dynamo_1.DyNTS_SingletonServ
     /** Modul betöltés időpontja — grace period számításhoz (process.uptime() nem használható,
      * mert a pipeline ugyanabban a Node.js process-ben fut a require-on keresztül). */
     moduleLoadedAt = Date.now();
+    /**
+     * BUG-CC-RESTART-RECOVERY-POLL-001 (2026-05-08): in-flight resumeSession check
+     * callback (cyclic-import elkerülésére). A manager bootstrap-kor regisztrálja
+     * `setResumeInFlightChecker((sessionId) => manager.isResumeInFlight(sessionId))`-vel.
+     * A `verifyAndKillIfStillClosed` használja, hogy ne ölje meg a friss runner-t,
+     * miközben a resumeSession épp DB-státusz reset-en dolgozik (200ms re-read race).
+     * Default: () => false (manager még nincs készen → konzervatív, nem véd).
+     */
+    resumeInFlightChecker = () => false;
+    /** Manager bootstrap-kor regisztrálja a checker-t. */
+    setResumeInFlightChecker(checker) {
+        this.resumeInFlightChecker = checker;
+    }
     /** Flapping detection: gyors connect/disconnect ciklusok számlálása per session.
      * count: window-based counter (FLAP_WINDOW_MS ablakon belüli disconnect-ek).
      * totalCount: kumulatív counter (az output/reset óta összesen — force-exit-hez). */
@@ -461,109 +471,32 @@ class CC_AdapterTerminal_ControlService extends nts_dynamo_1.DyNTS_SingletonServ
         if (fallbackUrl) {
             runnerArgs.push(`--fallbackServerUrl=${fallbackUrl}`);
         }
-        let lastSpawnError = '';
-        let spawned = false;
-        let spawnAttemptsCount = 0;
-        let chosenBinary = '';
-        if (process.platform === 'win32') {
-            const cmdArgs = [
-                '/c', 'start',
-                '/d', params.workspacePath,
-                title,
-                'node',
-                ...runnerArgs,
-            ];
-            // CMD spawn próba (multiple cmd.exe candidate paths, mint exec-terminal-manager).
-            const cmdCandidates = get_windows_cmd_spawn_candidate_paths_util_1.Tls_GetWindowsCmdSpawnCandidatePaths_Util.getWindowsCmdSpawnCandidatePaths();
-            spawnAttemptsCount = cmdCandidates.length;
-            for (const cmdPath of cmdCandidates) {
-                try {
-                    const child = (0, child_process_1.spawn)(cmdPath, cmdArgs, {
-                        detached: true,
-                        stdio: 'ignore',
-                        cwd: runnerDir,
-                    });
-                    attach_mandatory_child_process_error_handler_util_1.Tls_AttachMandatoryChildProcessErrorHandler_Util.attachMandatoryChildProcessErrorHandler({
-                        child: child,
-                        context: `CC_AdapterTerminal | spawn terminal runner (win32) | cmd=${cmdPath}`,
-                        onError: (err) => {
-                            lastSpawnError = err.message;
-                        },
-                    });
-                    child.unref();
-                    spawned = true;
-                    chosenBinary = cmdPath;
-                    fsm_dynamo_1.DyFM_Log.info(`CC_AdapterTerminal | terminal runner spawned (win32)`
-                        + ` | session: ${params.sessionId}`
-                        + ` | terminalId: ${terminalId}`
-                        + ` | cmd: ${cmdPath}`);
-                    break;
-                }
-                catch (err) {
-                    lastSpawnError = fsm_dynamo_1.DyFM_Error.getErrorMessage(err);
-                }
-            }
-        }
-        else {
-            // Linux: emulator detekció a Tls_LinuxTerminalSpawn_Util-ból (gnome-terminal / konsole /
-            // alacritty / kitty / tilix / xterm / x-terminal-emulator); headless host (nincs
-            // DISPLAY / WAYLAND) vagy hiányzó emulator → null → per-session fallback a caller-nél.
-            const plan = tls_linux_terminal_spawn_util_1.Tls_LinuxTerminalSpawn_Util.planSpawn({
-                workspacePath: params.workspacePath,
-                title: title,
-                command: 'node',
-                commandArgs: runnerArgs,
-            });
-            spawnAttemptsCount = plan ? 1 : 0;
-            if (!plan) {
-                lastSpawnError =
-                    'No usable Linux terminal emulator found (no $DISPLAY / $WAYLAND_DISPLAY, or no known' +
-                        ' emulator in PATH). Install gnome-terminal / konsole / xterm / etc. and ensure a graphical session.';
-            }
-            else {
-                try {
-                    const child = (0, child_process_1.spawn)(plan.binaryPath, plan.args, {
-                        detached: true,
-                        stdio: 'ignore',
-                        cwd: plan.cwd,
-                    });
-                    attach_mandatory_child_process_error_handler_util_1.Tls_AttachMandatoryChildProcessErrorHandler_Util.attachMandatoryChildProcessErrorHandler({
-                        child: child,
-                        context: `CC_AdapterTerminal | spawn terminal runner (linux) | emulator=${plan.emulatorKind}`,
-                        onError: (err) => {
-                            lastSpawnError = err.message;
-                        },
-                    });
-                    child.unref();
-                    spawned = true;
-                    chosenBinary = plan.binaryPath;
-                    fsm_dynamo_1.DyFM_Log.info(`CC_AdapterTerminal | terminal runner spawned (linux)`
-                        + ` | session: ${params.sessionId}`
-                        + ` | terminalId: ${terminalId}`
-                        + ` | emulator: ${plan.emulatorKind}`
-                        + ` | binary: ${plan.binaryPath}`);
-                }
-                catch (err) {
-                    lastSpawnError = fsm_dynamo_1.DyFM_Error.getErrorMessage(err);
-                }
-            }
-        }
-        if (!spawned) {
+        // Cycle 825: platform-specifikus spawn extracted to CC_TerminalRunnerSpawn_Util.
+        const spawnResult = await cc_terminal_runner_spawn_util_1.CC_TerminalRunnerSpawn_Util.spawnTerminalRunnerProcess({
+            sessionId: params.sessionId,
+            terminalId: terminalId,
+            workspacePath: params.workspacePath,
+            title: title,
+            runnerCommand: 'node',
+            runnerArgs: runnerArgs,
+            runnerCwd: runnerDir,
+        });
+        if (!spawnResult.spawned) {
             this.terminalIds.delete(params.sessionId);
             throw new ccap_error_control_model_1.CCAP_Error({
-                message: `Failed to spawn terminal runner: ${lastSpawnError}`,
+                message: `Failed to spawn terminal runner: ${spawnResult.lastSpawnError}`,
                 errorCode: 'CCAP-CCS-TERMINAL-SPAWN-FAIL',
                 status: 500,
-                error: new Error(`Failed to spawn terminal runner: ${lastSpawnError}`),
+                error: new Error(`Failed to spawn terminal runner: ${spawnResult.lastSpawnError}`),
                 additionalContent: eh_record_build_util_1.Eh_Record_BuildUtil.buildDyFmAdditionalContentForCcapTable({
                     additionalContext: {
                         source: 'cc-adapter-terminal | spawnTerminalRunner',
                         platform: process.platform,
                         ccSessionId: params.sessionId,
                         workspacePath: params.workspacePath,
-                        spawnAttemptsCount: spawnAttemptsCount,
-                        chosenBinary: chosenBinary,
-                        lastSpawnError: lastSpawnError,
+                        spawnAttemptsCount: spawnResult.spawnAttemptsCount,
+                        chosenBinary: spawnResult.chosenBinary,
+                        lastSpawnError: spawnResult.lastSpawnError,
                     },
                 }),
             });
@@ -628,14 +561,20 @@ class CC_AdapterTerminal_ControlService extends nts_dynamo_1.DyNTS_SingletonServ
             //    tűnik az üzenet"). A `runnerGracePeriodSec` lifecycle-célra (idle-timeout)
             //    van, NEM HTTP-send-blokkra. 30s bőven elég ahhoz, hogy egy érvényesen
             //    reconnect-elő runner befigyeljen; utána fail-fast → spawnTerminalRunner.
-            //  - had-runner-disconnected: rövidített grace (4 iter = 2s) — user-closed
-            //    window, runner nem fog visszajönni, ne blokkoljuk a HTTP request-et 30s-ig
+            //  - had-runner-disconnected: minimális grace (1 iter = 500ms).
+            //    BUG-CC-TERM-FAST-OPEN-001 (2026-05-08, cycle 805): a 2s wait gyakorlatilag
+            //    pure waste a tipikus user-closed window forgatókönyvben (runner Node-process
+            //    elment, semmi nincs amit várni). Cycle 263 még 4 iter-rel (2s) volt óvatos
+            //    — most a Socket.IO transient blip (500ms-en belüli auto-reconnect) is megfér
+            //    ebben az 1 iter-ben, és a túlnyomó többségi „klassszikus zárt-terminál" eset
+            //    1.5s-ot gyorsabb. A handleTerminalRegister stale-runner-rejection logika
+            //    (line ~1110) kezeli, ha a régi runner késve csatlakozik és újat is spawnoltunk.
             const graceCase = isServerRestartWindow
                 ? 'server-restart'
                 : 'had-runner-disconnected';
             const graceIterations = isServerRestartWindow
                 ? CC_AdapterTerminal_ControlService.computeServerRestartGraceIterations(this.runnerGracePeriodSec)
-                : 4;
+                : 1;
             fsm_dynamo_1.DyFM_Log.info(`CC_AdapterTerminal | grace-period-enter`
                 + ` | session: ${params.sessionId}`
                 + ` | hadRunner: ${this.hadRunnerSet.has(params.sessionId)}`
@@ -672,10 +611,38 @@ class CC_AdapterTerminal_ControlService extends nts_dynamo_1.DyNTS_SingletonServ
             }
         }
         if (!socket || !socket.connected) {
-            await this.spawnTerminalRunner({
+            // BUG-CC-TERM-FAST-OPEN-001 (2026-05-08, cycle 805): UI-feedback a spawn
+            // alatt. Eddig a user a spinner mögött ~1-2s-ig nem látott semmit, miközben
+            // a terminál ablak épp nyílt (gnome-terminal startup + Node runner cold-start
+            // + Socket.IO connect + cc:register). Most explicit `starting` státusz-push
+            // és statusMessage „Spawning terminal runner..." → a user lát feedback-et,
+            // hogy a rendszer dolgozik. A status-transition idempotens, a register utáni
+            // running-flip változatlan.
+            this.handleProcessStateChange({
                 sessionId: params.sessionId,
-                workspacePath: params.config.workspacePath,
+                status: cc_status_enum_1.CC_Status_Type.starting,
+                statusMessage: 'Spawning terminal runner — opening new window…',
             });
+            try {
+                await this.spawnTerminalRunner({
+                    sessionId: params.sessionId,
+                    workspacePath: params.config.workspacePath,
+                });
+            }
+            catch (spawnErr) {
+                // Spawn elhasalt (REG-TIMEOUT vagy SPAWN-FAIL) — a `starting` státusz
+                // ragadt volna meg, ami az `isBusyProcessing` busy-halmazában van, és
+                // a queue tryDeliverNext-et soha nem engedné kézbesíteni. Reset waitingInput-ra,
+                // hogy a következő prompt-küldés (vagy queue-retry) tisztán induljon.
+                // A spawn-hibát továbbra is throw-oljuk a hívási láncon felfelé (a route
+                // queue-fallback-je elnyeli ha transient, vagy /errors-be megy).
+                this.handleProcessStateChange({
+                    sessionId: params.sessionId,
+                    status: cc_status_enum_1.CC_Status_Type.waitingInput,
+                    statusMessage: `Terminal spawn failed — ${fsm_dynamo_1.DyFM_Error.getErrorCode(spawnErr) || 'unknown'}`,
+                });
+                throw spawnErr;
+            }
             socket = this.terminalSockets.get(params.sessionId);
         }
         if (!socket) {
@@ -863,7 +830,39 @@ class CC_AdapterTerminal_ControlService extends nts_dynamo_1.DyNTS_SingletonServ
         const sessionId = (params.data.sessionId ?? '').trim();
         const terminalId = (params.data.terminalId ?? '').trim();
         if (!sessionId || !terminalId) {
-            fsm_dynamo_1.DyFM_Log.warn('CC_AdapterTerminal | terminal register: missing sessionId or terminalId');
+            // BUG-CC-RUNNER-EVICT-VISIBILITY-001 (2026-05-07) Phase Silent-A: malformed
+            // register silent-drop megszüntetve. Eddig csak warn-log volt — a user nem
+            // látta hogy a runner próbálkozott regisztrálni hibás payload-dal, ami
+            // version-mismatch / outdated-runner / corrupt-state diagnosztika szempontjából
+            // kritikus. Most a /errors page-en is megjelenik.
+            fsm_dynamo_1.DyFM_Log.warn(`CC_AdapterTerminal | terminal register: missing sessionId or terminalId`
+                + ` | rawSessionId: '${params.data.sessionId ?? '(undefined)'}'`
+                + ` | rawTerminalId: '${params.data.terminalId ?? '(undefined)'}'`
+                + ` | rawRunnerVersion: '${params.data.runnerVersion ?? '(undefined)'}'`);
+            const malformedError = new ccap_error_control_model_1.CCAP_Error({
+                message: 'CC Session terminal runner sent malformed register payload: missing'
+                    + ` sessionId or terminalId. The runner cannot be associated with a session`
+                    + ` and was silently dropped — likely an outdated runner version or`
+                    + ` corrupted runtime state.`,
+                errorCode: 'CCAP-CCS-TERMINAL-MALFORMED-REGISTER',
+                status: 400,
+                error: new Error('Malformed cc:register payload — missing sessionId or terminalId'),
+                additionalContent: eh_record_build_util_1.Eh_Record_BuildUtil.buildDyFmAdditionalContentForCcapTable({
+                    additionalContext: {
+                        source: 'cc-adapter-terminal | handleTerminalRegister',
+                        rawSessionId: params.data.sessionId ?? null,
+                        rawTerminalId: params.data.terminalId ?? null,
+                        rawRunnerVersion: params.data.runnerVersion ?? null,
+                        ready: params.data.ready ?? null,
+                        hint: 'Az érkező runner cc:register payload-ja hiányos volt. Tipikus okok:\n'
+                            + '  (a) Outdated globális npm install (futtasd: `npm i -g'
+                            + ' @futdevpro/ccap@latest`).\n'
+                            + '  (b) Runner-process belső állapot-korrupciója (próbáld újraindítani).\n'
+                            + '  (c) Manuális Socket.IO klienssel csatlakozott külső eszköz.',
+                    },
+                }),
+            });
+            nts_dynamo_1.DyNTS_GlobalService.globalErrorHandler(malformedError);
             return;
         }
         // Cycle 781: runner version eltárolása. A régi (pre-cycle-781) runner-ek
@@ -929,6 +928,40 @@ class CC_AdapterTerminal_ControlService extends nts_dynamo_1.DyNTS_SingletonServ
                         + ` | session: ${sessionId}`
                         + ` | terminalId: ${terminalId}`
                         + ` | totalFlapCount: ${totalFlapCount}`);
+                    // BUG-CC-RUNNER-EVICT-VISIBILITY-001 (2026-05-07) Phase Silent-A: a flapping
+                    // force-exit eddig csak warn-log volt — a user a UI-on hirtelen ablak-bezárást
+                    // látott (a runner socket lekapcsolva, terminál gyakran exit-elve), és nem
+                    // értette miért. Most a /errors page-en explicit látszik az ok.
+                    const flapWindow = this.flapTracker.get(sessionId);
+                    const flapError = new ccap_error_control_model_1.CCAP_Error({
+                        message: `CC Session terminal runner force-exit due to flapping (rapid reconnect cycling)`
+                            + ` | session: ${sessionId} | totalFlapCount: ${totalFlapCount}`
+                            + ` | window: ${CC_AdapterTerminal_ControlService.FLAP_WINDOW_MS}ms`,
+                        errorCode: 'CCAP-CCS-TERMINAL-FLAPPING-FORCE-EXIT',
+                        status: 503,
+                        error: new Error(`Runner flapping force-exit (totalCount=${totalFlapCount},`
+                            + ` threshold=${CC_AdapterTerminal_ControlService.FLAP_FORCE_EXIT_THRESHOLD})`),
+                        additionalContent: eh_record_build_util_1.Eh_Record_BuildUtil.buildDyFmAdditionalContentForCcapTable({
+                            additionalContext: {
+                                source: 'cc-adapter-terminal | handleTerminalRegister | flapping-force-exit',
+                                ccSessionId: sessionId,
+                                terminalId: terminalId,
+                                totalFlapCount: totalFlapCount,
+                                windowFlapCount: flapWindow?.count ?? 0,
+                                forceExitThreshold: CC_AdapterTerminal_ControlService.FLAP_FORCE_EXIT_THRESHOLD,
+                                flapWindowMs: CC_AdapterTerminal_ControlService.FLAP_WINDOW_MS,
+                                hint: 'A runner túl gyakran csatlakozott le-fel az időablakon belül,'
+                                    + ' a server kényszerített disconnect-tel megszakította. Tipikus okok:\n'
+                                    + '  (a) Runner version-mismatch / corrupt npm cache → futtasd:'
+                                    + ' `npm i -g @futdevpro/ccap@latest`.\n'
+                                    + '  (b) Hálózati instabilitás (proxy, VPN reconnect-loop).\n'
+                                    + '  (c) Runner-side bug a Socket.IO reconnect-loop logikában.\n'
+                                    + '  Megoldás: várd meg, majd Restart Runner. Ha visszatér: nézd a'
+                                    + ' runner-window-ot a hibaüzenetért, és frissítsd a runner-t.',
+                            },
+                        }),
+                    });
+                    nts_dynamo_1.DyNTS_GlobalService.globalErrorHandler(flapError);
                     this.flapTracker.delete(sessionId);
                     try {
                         params.socket.disconnect(true);
@@ -1022,10 +1055,8 @@ class CC_AdapterTerminal_ControlService extends nts_dynamo_1.DyNTS_SingletonServ
         });
     }
     /**
-     * Terminal runner output event kezelése (cc:output).
-     * Sequence-based dedup (REQ-CCSESS-TR-002): ha a beérkező sequence <= utolsó feldolgozott,
-     * az item duplikát (reconnect race) → eldobjuk, nem propagáljuk a manager-hez.
-     * Sikeres feldolgozás után debounce-olt ack-ot kezdeményezünk a runner felé.
+     * cc:output event handler. Sequence dedup REQ-CCSESS-TR-002 (sequence <= last → drop),
+     * sikeres feldolgozás → debounce-olt ack a runner felé.
      */
     handleTerminalOutput(params) {
         const data = params.data;
@@ -1072,10 +1103,9 @@ class CC_AdapterTerminal_ControlService extends nts_dynamo_1.DyNTS_SingletonServ
         }
     }
     /**
-     * Throttle-olt ack emit a runner felé (REQ-CCSESS-TR-002). Folyamatos output mellett is
-     * legalább 500ms-onként kimegy az ack — ellentétben a debounce-szal, ami csak output-szünetben
-     * lőne. A pendingAckSequence map tárolja a legmagasabb még nem ack-olt sequence-t; a timer
-     * fire-kor a **friss** socket-et olvassuk ki (a reconnect közben a socket referencia cserélődhet).
+     * Throttle-olt ack emit (REQ-CCSESS-TR-002): legalább 500ms-onként folyamatos output mellett
+     * (debounce csak output-szünetben lőne). pendingAckSequence map a legmagasabb pending sequence-t
+     * tárolja, timer fire-kor a friss socket-et olvassa (reconnect cserélheti a socket ref-et).
      */
     scheduleAck(params) {
         // Mindig frissítsük a pending sequence-t a legmagasabbra.
@@ -1290,7 +1320,45 @@ class CC_AdapterTerminal_ControlService extends nts_dynamo_1.DyNTS_SingletonServ
                     + ` | terminalId: ${terminalId}`
                     + ` | reason: ${reason ?? 'unknown'}`
                     + ` | flap: ${this.flapTracker.get(sessionId)?.count ?? 0}/${this.flapTracker.get(sessionId)?.totalCount ?? 0}`);
-                // DB státusz frissítése.
+                // BUG-CC-RUNNER-EVICT-VISIBILITY-001 (2026-05-07) Phase Silent-A: ha az
+                // disconnect oka NEM a tervezett kill (pendingKillReasons üres erre a
+                // sessionre), akkor unexpected — érdemes /errors-be rögzíteni, hogy a
+                // user lássa a runner-vesztés okát (network blip, runner-crash, X server
+                // reset, manual close). A tervezett kill-ekre (user-terminate, runner-restart,
+                // process-replace, lifecycle, stb.) silent — a process-exit handler
+                // úgyis rögzít state-change event-et.
+                const pendingKillReason = this.pendingKillReasons.get(sessionId);
+                if (!pendingKillReason) {
+                    const disconnectError = new ccap_error_control_model_1.CCAP_Error({
+                        message: `CC Session terminal runner unexpectedly disconnected`
+                            + ` | session: ${sessionId} | socketReason: ${reason ?? 'unknown'}`,
+                        errorCode: 'CCAP-CCS-TERMINAL-UNEXPECTED-DISCONNECT',
+                        status: 503,
+                        error: new Error(`Terminal runner unexpectedly disconnected: ${reason ?? 'unknown'}`),
+                        additionalContent: eh_record_build_util_1.Eh_Record_BuildUtil.buildDyFmAdditionalContentForCcapTable({
+                            additionalContext: {
+                                source: 'cc-adapter-terminal | handleTerminalDisconnect',
+                                ccSessionId: sessionId,
+                                terminalId: terminalId,
+                                socketReason: reason ?? 'unknown',
+                                flapCount: this.flapTracker.get(sessionId)?.count ?? 0,
+                                flapTotalCount: this.flapTracker.get(sessionId)?.totalCount ?? 0,
+                                hint: 'A runner socket-je váratlanul lecsatlakozott (NEM intencionált'
+                                    + ' kill volt). Tipikus okok a Socket.IO `reason` mező alapján:\n'
+                                    + '  - "transport error" → hálózati / proxy hiba.\n'
+                                    + '  - "ping timeout" → runner unresponsive (event-loop blokkolva, OS-szint).\n'
+                                    + '  - "io server disconnect" → szerver explicit szakította meg.\n'
+                                    + '  - "client namespace disconnect" → runner process explicit kilépett.\n'
+                                    + '  - "transport close" → terminál ablakot bezárta a user vagy az'
+                                    + ' emulator (claude exitelt és a window auto-close-olt).\n'
+                                    + '  Ha repeated → BUG-CC-TERM-CLOSE-PREMATURE-001 vagy network instability.',
+                            },
+                        }),
+                    });
+                    nts_dynamo_1.DyNTS_GlobalService.globalErrorHandler(disconnectError);
+                }
+                // DB státusz frissítése. .catch() → DyFM_Error.logSimple a server logba —
+                // ha a DB nem elérhető, az nem visszafordítható itt, de legalább látszik.
                 if (terminalId) {
                     const termDS = new cc_terminal_data_service_1.CC_Terminal_DataService({ issuer: 'cc-adapter-terminal' });
                     termDS.findByTerminalId(terminalId).then((doc) => {
@@ -1298,9 +1366,15 @@ class CC_AdapterTerminal_ControlService extends nts_dynamo_1.DyNTS_SingletonServ
                             termDS.updateStatus({
                                 id: doc._id,
                                 status: ac_exec_terminal_window_status_enum_1.AC_ExecTerminalWindowStatus_Type.disconnected,
-                            }).catch(() => { });
+                            }).catch((updateErr) => {
+                                fsm_dynamo_1.DyFM_Error.logSimple(`CC_AdapterTerminal | DB updateStatus(disconnected) failed`
+                                    + ` | session: ${sessionId} | terminalId: ${terminalId}`, updateErr);
+                            });
                         }
-                    }).catch(() => { });
+                    }).catch((findErr) => {
+                        fsm_dynamo_1.DyFM_Error.logSimple(`CC_AdapterTerminal | DB findByTerminalId failed`
+                            + ` | session: ${sessionId} | terminalId: ${terminalId}`, findErr);
+                    });
                 }
                 // Session manager értesítése: a futó prompt elveszett (runner ablak bezárva).
                 // waitingInput-ra váltunk, hogy a user azonnal újra tudjon küldeni.
@@ -1352,10 +1426,9 @@ class CC_AdapterTerminal_ControlService extends nts_dynamo_1.DyNTS_SingletonServ
         }
     }
     /**
-     * Lazy session config reload DB-ből (fire-and-forget).
-     * Szerver restart után az in-memory sessionConfigs üres — a visszacsatlakozó runner-nek
-     * szüksége van a config-ra (model, effort, mode, stb.) a következő prompt-nál.
-     * Ha a session nem található a DB-ben, logol és nem hoz létre config-ot.
+     * Lazy session config reload DB-ből (fire-and-forget). Server restart után az in-memory
+     * sessionConfigs üres — a visszacsatlakozó runner-nek kell config (model, effort, mode);
+     * ha a session DB-ben nincs, logol és nem hoz létre config-ot.
      */
     reloadSessionConfigFromDb(params) {
         const localCcapId = instance_id_service_1.ExS_InstanceId_Service.getInstance().getInstanceId();
@@ -1391,9 +1464,33 @@ class CC_AdapterTerminal_ControlService extends nts_dynamo_1.DyNTS_SingletonServ
                 + ` | model: ${config.model ?? 'default'}`
                 + ` | effort: ${config.reasoningEffort ?? 'default'}`);
         }).catch((err) => {
+            // BUG-CC-RUNNER-EVICT-VISIBILITY-001 (2026-05-07) Phase Silent-A: a
+            // config-reload csendben hibázott — a következő prompt default config-gal
+            // futott (a model / reasoningEffort / mode beállítások elvesztek a session-ből).
+            // Most a /errors page-en is látszik, hogy a felhasználó tudjon róla.
             fsm_dynamo_1.DyFM_Log.error(`CC_AdapterTerminal | reloadSessionConfigFromDb failed`
                 + ` | sessionId: ${params.sessionId}`
                 + ` | error: ${fsm_dynamo_1.DyFM_Error.getErrorMessage(err)}`);
+            const reloadError = new ccap_error_control_model_1.CCAP_Error({
+                message: `CC Session config reload from DB failed — subsequent prompts will use`
+                    + ` default configuration (model / reasoning effort / mode / permission policy).`,
+                errorCode: 'CCAP-CCS-CONFIG-RELOAD-FAILED',
+                status: 500,
+                error: err instanceof Error ? err : new Error(String(err)),
+                additionalContent: eh_record_build_util_1.Eh_Record_BuildUtil.buildDyFmAdditionalContentForCcapTable({
+                    additionalContext: {
+                        source: 'cc-adapter-terminal | reloadSessionConfigFromDb',
+                        ccSessionId: params.sessionId,
+                        localCcapId: localCcapId,
+                        hint: 'A session-config reload sikertelen volt. A user szempontjából a következő'
+                            + ' prompt-nál a Claude default beállításokkal fut, ami nemkívánt viselkedést'
+                            + ' eredményezhet (rossz model, rossz reasoning effort). Megoldás:\n'
+                            + '  - Nézd meg a DB-elérhetőséget (mongo logs, replica lag).\n'
+                            + '  - Ha visszatér: a session config-ját explicit állítsd újra a UI-on.',
+                    },
+                }),
+            });
+            nts_dynamo_1.DyNTS_GlobalService.globalErrorHandler(reloadError);
         });
     }
     // ── Private callback helpers ─────────────────────────────────
@@ -1425,10 +1522,9 @@ class CC_AdapterTerminal_ControlService extends nts_dynamo_1.DyNTS_SingletonServ
     }
     // ── Private: session completion guard ─────────────────────────
     /**
-     * Session lezárás guard: ha a session DB-állapota completed/terminated/errored vagy
-     * törölt, a runner-t cc:kill + disconnect-tel kiutasítjuk (fire-and-forget).
-     * Tipikus eset: server restart → recovery lezárta a session-t, de a runner CMD ablak
-     * túlélte és reconnect-elt — enélkül idle-timeout-ig nyitva maradna.
+     * Completion guard: ha a session DB completed/terminated/errored/deleted, runner cc:kill +
+     * disconnect (fire-and-forget). Tipikus: server restart-recovery lezárta, de runner ablak
+     * túlélte és reconnect-elt — idle-timeout-ig nyitva maradna.
      */
     rejectRunnerIfSessionClosed(params) {
         const localCcapId = instance_id_service_1.ExS_InstanceId_Service.getInstance().getInstanceId();
@@ -1483,12 +1579,9 @@ class CC_AdapterTerminal_ControlService extends nts_dynamo_1.DyNTS_SingletonServ
         });
     }
     /**
-     * Második DB-olvasás a kill előtt — race elkerülése.
-     *
-     * Ha a session DB állapota az első olvasás óta `creating`/`starting`/`running`/`waiting-input`/`stalled`
-     * állapotra változott (pl. resumeSession lefutott közben), nem öljük a runnert — a session
-     * aktívan használatban van. Ha viszont továbbra is closed (completed/terminated/errored),
-     * akkor valódi orphan, ki kell ütni.
+     * Második DB-olvasás kill előtt (race elkerülés). Ha az állapot creating/starting/running/
+     * waiting-input/stalled-ra váltott (pl. resumeSession közben), NEM ölünk — aktív session.
+     * Ha továbbra is closed (completed/terminated/errored) → valódi orphan, kill.
      */
     verifyAndKillIfStillClosed(params) {
         const localCcapId = instance_id_service_1.ExS_InstanceId_Service.getInstance().getInstanceId();
@@ -1510,6 +1603,20 @@ class CC_AdapterTerminal_ControlService extends nts_dynamo_1.DyNTS_SingletonServ
                 return;
             }
             if (params.closedStatuses.includes(session.status ?? '')) {
+                // BUG-CC-RESTART-RECOVERY-POLL-001 (2026-05-08): in-flight resumeSession
+                // race-protect. Ha a sessionre éppen FUT egy resumeSession (a manager
+                // resumeInFlight Set-jében szerepel), akkor a 200ms re-read DB-snapshot
+                // még a stale closed-státuszt mutathatja (a resumeSession DB-write még
+                // nem committolt). Ne öljük meg a friss runner-t — a resumeSession be fogja
+                // állítani a státuszt creating-re és a runner felhasználható.
+                if (this.resumeInFlightChecker(params.sessionId)) {
+                    fsm_dynamo_1.DyFM_Log.info(`CC_AdapterTerminal | runner KEPT (resume in-flight): DB still shows closed,`
+                        + ` but resumeSession is currently running and will set status to creating shortly`
+                        + ` | session: ${params.sessionId}`
+                        + ` | terminalId: ${params.terminalId}`
+                        + ` | dbStatus: ${session.status}`);
+                    return;
+                }
                 // Még mindig closed → valódi orphan, kill.
                 // BUG-CC-RUNNER-EVICT-VISIBILITY-001 (2026-05-07): user-visible error
                 // record a /errors page-en. Eddig csak warn-log volt, a user nem látta