awb-agent-manager 1.0.0

package/dist/lib/base-session-manager.js

@@ -0,0 +1,667 @@
+import { promises as fsp } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { createInterface } from 'node:readline';
+import { spawn } from 'node:child_process';
+import { SUBAGENTS_BASE_DIR, STOP_GRACE_MS } from './constants.js';
+import { log } from './logging.js';
+import { summarizeCliEvent } from './cli-output-summary.js';
+import { createAdapter } from './cli-adapters/index.js';
+import { ADAPTER_CAPABILITIES, PARSE_STAGE, describeHarness, partitionHarness, selectEffortSlice, } from './cli-adapters/base.js';
+const { PERSISTENT_SESSION } = ADAPTER_CAPABILITIES;
+const UNHEALTHY_TURN_THRESHOLD = 5;
+const UNHEALTHY_DURATION_MS = 30 * 60 * 1000;
+const HEALTH_SWEEP_INTERVAL_MS = 60 * 1000;
+const OUTPUT_RING_MAX = 100;
+export class BaseSessionManager {
+    _config;
+    #adapters = new Map();
+    _sessions = new Map();
+    _inflight = new Map();
+    _outputRings = new Map();
+    #dedupSet = new Set();
+    #dedupQueue = [];
+    #DEDUP_MAX = 200;
+    #healthTimer = null;
+    #keyField;
+    #logTag;
+    #cfgPrefix;
+    #kindLabel;
+    #monitor = null;
+    constructor(config, options) {
+        this._config = config;
+        this.#keyField = options.keyField;
+        this.#logTag = options.logTag;
+        this.#cfgPrefix = options.cfgPrefix;
+        this.#kindLabel = options.kindLabel;
+    }
+    get _adapter() {
+        return this._adapterFor('claude');
+    }
+    _adapterFor(cli) {
+        const t = String(cli || 'claude').toLowerCase();
+        let a = this.#adapters.get(t);
+        if (!a) {
+            a = createAdapter(t);
+            this.#adapters.set(t, a);
+        }
+        return a;
+    }
+    setMonitor(monitor) {
+        this.#monitor = monitor;
+    }
+    _getSession(sessionKey) {
+        return this._sessions.get(sessionKey);
+    }
+    _isPidAlive(pid) {
+        if (!pid || pid <= 0)
+            return false;
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch (err) {
+            return err?.code === 'EPERM';
+        }
+    }
+    _getLiveSession(sessionKey) {
+        const sess = this._sessions.get(sessionKey);
+        if (!sess)
+            return undefined;
+        if (sess.unhealthyKilled) {
+            log(`${this.#logTag} unhealthy ${this.#keyField}=${sessionKey} pid=${sess.pid} — not reusing a session under teardown; purging in-memory record`);
+            if (sess.idleTimer) {
+                clearTimeout(sess.idleTimer);
+                sess.idleTimer = null;
+            }
+            this.#endTurn(sess);
+            this._sessions.delete(sessionKey);
+            return undefined;
+        }
+        if (this._isPidAlive(sess.pid))
+            return sess;
+        log(`${this.#logTag} stale ${this.#keyField}=${sessionKey} pid=${sess.pid} — child reaped without exit-handler cleanup; purging in-memory record`);
+        if (sess.idleTimer) {
+            clearTimeout(sess.idleTimer);
+            sess.idleTimer = null;
+        }
+        this.#endTurn(sess);
+        this._sessions.delete(sessionKey);
+        return undefined;
+    }
+    _ensureCapacity() {
+        const cap = this._config.delegation.maxConcurrent ?? 5;
+        if (this._sessions.size < cap)
+            return true;
+        return this.#evictLru();
+    }
+    async _spawnSession(sessionKey, rolePrompt, firstTurnText, { onProgress, monitorMeta, agentContext, firstTurnImages, harness: rawHarness, effortPreset, envVars } = {}) {
+        const adapter = this._adapterFor(agentContext?.cli);
+        if (!adapter.has(PERSISTENT_SESSION)) {
+            log(`${this.#logTag} adapter cli=${adapter.cliType} does not support persistent sessions; refusing to spawn`);
+            return null;
+        }
+        const effectiveApiKey = agentContext?.api_key || this._config.apiKey;
+        const effectiveCwd = agentContext?.cwd || undefined;
+        const { applied: harness, skipped: harnessSkipped } = partitionHarness(adapter, rawHarness);
+        if (harnessSkipped.length > 0) {
+            log(`${this.#logTag} harness keys skipped (cli=${adapter.cliType} can't express them): ${harnessSkipped.join(', ')}`);
+        }
+        if (harness) {
+            log(`${this.#logTag} harness applied: ${this.#keyField}=${sessionKey} cli=${adapter.cliType} ${describeHarness(harness)}`);
+        }
+        const slice = selectEffortSlice(adapter.cliType, effortPreset);
+        const effectiveModel = slice?.model ?? harness?.model ?? agentContext?.model ?? null;
+        const effortFlag = slice?.effort ?? null;
+        const ultracode = !!slice?.ultracode;
+        if (slice && (effortFlag || ultracode || slice.model)) {
+            log(`${this.#logTag} effort applied: ${this.#keyField}=${sessionKey} cli=${adapter.cliType} ` +
+                `effort=${effortFlag ?? '-'} ultracode=${ultracode} model=${slice.model ?? '-'}`);
+        }
+        let configPath = null;
+        let configPathIsTemp = false;
+        let pidPath = null;
+        try {
+            let descriptor = adapter.buildSessionSpawn({
+                rolePrompt: rolePrompt || '',
+                mcpConfigPath: null,
+                model: effectiveModel,
+                harness,
+                effort: effortFlag,
+                ultracode,
+            });
+            if (descriptor.needsMcpConfig) {
+                const needsSessionPin = !!(monitorMeta?.ticket_id && monitorMeta?.role);
+                if (agentContext?.mcp_config_path && !needsSessionPin) {
+                    configPath = agentContext.mcp_config_path;
+                    configPathIsTemp = false;
+                }
+                else {
+                    configPath = join(SUBAGENTS_BASE_DIR, `${this.#cfgPrefix}${Date.now()}-${Math.random().toString(36).slice(2)}.json`);
+                    configPathIsTemp = true;
+                    await fsp.mkdir(dirname(configPath), { recursive: true, mode: 0o700 });
+                    const headers = {
+                        Authorization: `Bearer ${effectiveApiKey}`,
+                        'X-AWB-Client-Type': agentContext ? 'managed-subagent' : 'subagent',
+                    };
+                    if (monitorMeta?.ticket_id)
+                        headers['X-AWB-Subagent-Ticket-Id'] = monitorMeta.ticket_id;
+                    if (monitorMeta?.role)
+                        headers['X-AWB-Subagent-Role'] = monitorMeta.role;
+                    if (monitorMeta?.trigger_source)
+                        headers['X-AWB-Subagent-Trigger-Source'] = monitorMeta.trigger_source;
+                    const mcpConfig = {
+                        mcpServers: {
+                            awb: {
+                                type: 'http',
+                                url: `${this._config.url.replace(/\/$/, '')}/mcp`,
+                                headers,
+                            },
+                        },
+                    };
+                    await fsp.writeFile(configPath, JSON.stringify(mcpConfig), { mode: 0o600 });
+                }
+                descriptor = adapter.buildSessionSpawn({
+                    rolePrompt: rolePrompt || '',
+                    mcpConfigPath: configPath,
+                    model: effectiveModel,
+                    harness,
+                    effort: effortFlag,
+                    ultracode,
+                });
+            }
+            const binOverride = adapter.cliType === 'claude' ? this._config.delegation.claudeBin : null;
+            const resolvedBin = adapter.resolveBin(binOverride);
+            const cliHomeEnvKey = adapter.configDirEnv();
+            const cliHomeEnv = cliHomeEnvKey && agentContext?.cli_home_dir
+                ? { [cliHomeEnvKey]: agentContext.cli_home_dir }
+                : {};
+            const credentialEnv = agentContext?.extra_env ?? {};
+            const baseEnv = { ...process.env };
+            if (agentContext?.credential_provider) {
+                const stripped = [];
+                for (const k of adapter.authEnvKeys()) {
+                    if (k in baseEnv) {
+                        delete baseEnv[k];
+                        stripped.push(k);
+                    }
+                }
+                if (stripped.length > 0) {
+                    log(`${this.#logTag} env strip: agent=${agentContext.agent_id.slice(0, 8)} ` +
+                        `provider=${agentContext.credential_provider} removed=${stripped.join(',')} ` +
+                        `(operator-inherited auth would have overridden per-agent credential)`);
+                }
+            }
+            const child = spawn(resolvedBin, descriptor.args, {
+                stdio: descriptor.stdio || ['pipe', 'pipe', 'pipe'],
+                detached: process.platform !== 'win32',
+                windowsHide: true,
+                cwd: effectiveCwd,
+                env: {
+                    ...baseEnv,
+                    ...(envVars ?? {}),
+                    AWB_API_KEY: effectiveApiKey,
+                    ...cliHomeEnv,
+                    ...credentialEnv,
+                    ...adapter.harnessEnv(harness),
+                },
+                shell: descriptor.shell ?? /\.(cmd|bat|ps1)$/i.test(resolvedBin),
+            });
+            child.once('error', (err) => {
+                log(`${this.#logTag} spawn error: code=${err?.code || ''} cli=${adapter.cliType} bin=${resolvedBin} msg=${err?.message}`);
+            });
+            child.unref();
+            if (!child.pid) {
+                if (configPath && configPathIsTemp)
+                    await fsp.unlink(configPath).catch(() => { });
+                return null;
+            }
+            if (configPath && configPathIsTemp) {
+                pidPath = configPath.replace(/\.json$/, '.pid');
+                await fsp.writeFile(pidPath, String(child.pid), { mode: 0o600 }).catch(() => { });
+            }
+            const sess = {
+                [this.#keyField]: sessionKey,
+                pid: child.pid,
+                cli_type: adapter.cliType,
+                adapter,
+                child,
+                configPath,
+                configPathIsTemp,
+                pidPath,
+                turnCount: 0,
+                startedAt: Date.now(),
+                lastTouchedAt: Date.now(),
+                idleTimer: null,
+                unrespondedTurnCount: 0,
+                unrespondedSince: null,
+                unhealthyKilled: false,
+                tap: null,
+            };
+            sess.tap =
+                this.#monitor?.register({
+                    kind: this.#kindLabel === 'chat_session'
+                        ? 'chat'
+                        : this.#kindLabel === 'ticket_session'
+                            ? 'ticket'
+                            : 'oneshot',
+                    sessionKey,
+                    pid: child.pid,
+                    ticketId: monitorMeta?.ticket_id,
+                    ticketTitle: monitorMeta?.ticket_title,
+                    role: monitorMeta?.role,
+                    apiKey: agentContext?.api_key,
+                }) || null;
+            this.#wireStdio(sess);
+            this.#wireExit(sess);
+            log(`${this.#logTag} spawned new pid=${sess.pid} cli=${adapter.cliType} kind=${this.#kindLabel} ${this.#keyField}=${sessionKey}`);
+            this.#startTurn(sess, onProgress);
+            this._writeTurn(sess, firstTurnText, firstTurnImages);
+            sess.turnCount = 1;
+            this._resetIdleTimer(sess);
+            this._sessions.set(sessionKey, sess);
+            this.#ensureHealthSweep();
+            return sess;
+        }
+        catch (err) {
+            log(`${this.#logTag} spawn error ${this.#keyField}=${sessionKey}: ${err?.message ?? err}`);
+            if (configPath && configPathIsTemp)
+                await fsp.unlink(configPath).catch(() => { });
+            return null;
+        }
+    }
+    _sendFollowUp(sess, turnText, { checkMaxTurns = true, onProgress, images, } = {}) {
+        this.#startTurn(sess, onProgress);
+        this._writeTurn(sess, turnText, images);
+        sess.turnCount++;
+        sess.lastTouchedAt = Date.now();
+        this._resetIdleTimer(sess);
+        if (!checkMaxTurns)
+            return;
+        const maxTurns = this._config.delegation.maxTurnsPerSession ?? 30;
+        if (sess.turnCount >= maxTurns) {
+            log(`${this.#logTag} ${this.#keyField}=${sess[this.#keyField]} hit maxTurns=${maxTurns}, closing stdin for respawn`);
+            try {
+                sess.child.stdin.end();
+            }
+            catch {
+            }
+        }
+    }
+    #startTurn(sess, onProgress) {
+        this.#endTurn(sess);
+        if (typeof onProgress !== 'function')
+            return;
+        const turn = {
+            onProgress,
+            stage: null,
+            fired: { thinking: false, composing: false },
+            heartbeatTimer: null,
+        };
+        sess._currentTurn = turn;
+        turn.heartbeatTimer = setInterval(() => {
+            if (sess._currentTurn === turn && turn.stage) {
+                try {
+                    turn.onProgress(turn.stage);
+                }
+                catch (err) {
+                    log(`${this.#logTag} onProgress heartbeat error: ${err?.message ?? err}`);
+                }
+            }
+        }, 10_000);
+        turn.heartbeatTimer.unref?.();
+    }
+    #endTurn(sess) {
+        const turn = sess._currentTurn;
+        if (!turn)
+            return;
+        if (turn.heartbeatTimer)
+            clearInterval(turn.heartbeatTimer);
+        sess._currentTurn = null;
+    }
+    #advanceTurn(sess, parsed) {
+        const turn = sess._currentTurn;
+        if (!turn)
+            return;
+        if (!turn.fired.thinking && parsed.stage) {
+            turn.fired.thinking = true;
+            turn.stage = PARSE_STAGE.THINKING;
+            try {
+                turn.onProgress(PARSE_STAGE.THINKING);
+            }
+            catch (err) {
+                log(`${this.#logTag} onProgress(thinking) error: ${err?.message ?? err}`);
+            }
+        }
+        if (!turn.fired.composing && parsed.stage === PARSE_STAGE.COMPOSING) {
+            turn.fired.composing = true;
+            turn.stage = PARSE_STAGE.COMPOSING;
+            try {
+                turn.onProgress(PARSE_STAGE.COMPOSING);
+            }
+            catch (err) {
+                log(`${this.#logTag} onProgress(composing) error: ${err?.message ?? err}`);
+            }
+        }
+        if (parsed.isResult) {
+            sess.unrespondedTurnCount = 0;
+            sess.unrespondedSince = null;
+            try {
+                sess.onResult?.(parsed.raw);
+            }
+            catch (err) {
+                log(`${this.#logTag} onResult error: ${err?.message ?? err}`);
+            }
+            this.#endTurn(sess);
+        }
+    }
+    _writeTurn(sess, text, images) {
+        const wire = sess.adapter.formatTurn(String(text), images);
+        try {
+            sess.child.stdin.write(wire + '\n');
+            sess.tap?.inLine(wire);
+            sess.unrespondedTurnCount = (sess.unrespondedTurnCount || 0) + 1;
+            if (!sess.unrespondedSince)
+                sess.unrespondedSince = Date.now();
+            log(`${this.#logTag} dispatched turn ${this.#keyField}=${sess[this.#keyField]} pid=${sess.pid} turn=${sess.turnCount + 1} bytes=${Buffer.byteLength(text)}`);
+        }
+        catch (err) {
+            log(`${this.#logTag} stdin write failed pid=${sess.pid}: ${err?.message ?? err}`);
+            return;
+        }
+        if (sess.unrespondedTurnCount >= UNHEALTHY_TURN_THRESHOLD) {
+            this.#killUnhealthy(sess, `${sess.unrespondedTurnCount} consecutive turns without an LLM response`);
+        }
+    }
+    #wireStdio(sess) {
+        if (sess.child.stdout) {
+            const rlOut = createInterface({ input: sess.child.stdout });
+            const tag = this.#logTag.replace(/^\[|\]$/g, '');
+            rlOut.on('line', (line) => {
+                sess.tap?.outLine(line);
+                const parsed = sess.adapter.parseStdoutLine(line);
+                if (parsed.stage || parsed.isResult) {
+                    sess.unrespondedTurnCount = 0;
+                    sess.unrespondedSince = null;
+                }
+                this.#advanceTurn(sess, parsed);
+                if (!parsed.raw) {
+                    const trimmed = line.trim();
+                    if (trimmed)
+                        this.#pushOutputLine(sess.pid, trimmed);
+                }
+                else {
+                    const summary = summarizeCliEvent(parsed.raw);
+                    if (summary)
+                        this.#pushOutputLine(sess.pid, summary);
+                }
+                this._onStdoutParsed(sess, parsed, line);
+                if (parsed.isResult) {
+                    const subtype = parsed.raw?.subtype || '-';
+                    const isError = parsed.isError === true ? 'true' : (parsed.raw?.is_error ?? '-');
+                    log(`[${tag}:${sess.pid}] result subtype=${subtype} is_error=${isError}`);
+                }
+            });
+        }
+        if (sess.child.stderr) {
+            const rlErr = createInterface({ input: sess.child.stderr });
+            const tag = this.#logTag.replace(/^\[|\]$/g, '');
+            rlErr.on('line', (line) => {
+                log(`[${tag}:${sess.pid}:err] ${line}`);
+                const trimmed = line.trim();
+                if (trimmed)
+                    this.#pushOutputLine(sess.pid, trimmed);
+                this._onStderrLine(sess, line);
+            });
+        }
+    }
+    #pushOutputLine(pid, line) {
+        let ring = this._outputRings.get(pid);
+        if (!ring) {
+            ring = [];
+            this._outputRings.set(pid, ring);
+        }
+        ring.push(line);
+        while (ring.length > OUTPUT_RING_MAX)
+            ring.shift();
+    }
+    _collectOutputTail(pid, maxChars) {
+        const ring = this._outputRings.get(pid);
+        if (!ring || ring.length === 0)
+            return '';
+        let body = ring.join('\n').trim();
+        if (maxChars > 0 && body.length > maxChars) {
+            body = '…' + body.slice(-maxChars);
+        }
+        return body;
+    }
+    _clearOutputBuffer(pid) {
+        this._outputRings.delete(pid);
+    }
+    #wireExit(sess) {
+        sess.child.once('exit', async (code, signal) => {
+            if (sess.idleTimer) {
+                clearTimeout(sess.idleTimer);
+                sess.idleTimer = null;
+            }
+            this.#endTurn(sess);
+            const durationSec = Math.round((Date.now() - sess.startedAt) / 1000);
+            const key = sess[this.#keyField];
+            sess.tap?.end({ exit_code: code, signal });
+            log(`${this.#logTag} exit pid=${sess.pid} ${this.#keyField}=${key} code=${code} signal=${signal || '-'} turns=${sess.turnCount} duration=${durationSec}s`);
+            try {
+                await this._onChildExit(sess, code, signal);
+            }
+            catch (err) {
+                log(`${this.#logTag} _onChildExit error: ${err?.message ?? err}`);
+            }
+            this._clearOutputBuffer(sess.pid);
+            if (this._sessions.get(key) === sess)
+                this._sessions.delete(key);
+            if (sess.configPath && sess.configPathIsTemp) {
+                try {
+                    await fsp.unlink(sess.configPath);
+                }
+                catch {
+                }
+            }
+            if (sess.pidPath) {
+                try {
+                    await fsp.unlink(sess.pidPath);
+                }
+                catch {
+                }
+            }
+        });
+        sess.child.once('error', (err) => log(`${this.#logTag} child error pid=${sess.pid}: ${err?.message ?? err}`));
+    }
+    _resetIdleTimer(sess) {
+        if (sess.idleTimer)
+            clearTimeout(sess.idleTimer);
+        const mins = this._config.delegation.idleMinutes ?? 10;
+        sess.idleTimer = setTimeout(() => {
+            log(`${this.#logTag} idle, closing stdin ${this.#keyField}=${sess[this.#keyField]} pid=${sess.pid}`);
+            try {
+                sess.child.stdin.end();
+            }
+            catch {
+            }
+        }, mins * 60_000);
+        sess.idleTimer.unref?.();
+    }
+    _onStdoutParsed(_sess, _parsed, _rawLine) { }
+    _onStderrLine(_sess, _line) { }
+    async _onChildExit(_sess, _code, _signal) { }
+    #ensureHealthSweep() {
+        if (this.#healthTimer)
+            return;
+        this.#healthTimer = setInterval(() => this.#healthSweep(), HEALTH_SWEEP_INTERVAL_MS);
+        this.#healthTimer.unref?.();
+    }
+    #healthSweep() {
+        const now = Date.now();
+        for (const sess of this._sessions.values()) {
+            if (sess.unhealthyKilled)
+                continue;
+            if (!sess.unrespondedSince)
+                continue;
+            const elapsed = now - sess.unrespondedSince;
+            if (elapsed >= UNHEALTHY_DURATION_MS) {
+                this.#killUnhealthy(sess, `${Math.round(elapsed / 60_000)}m elapsed without an LLM response`);
+            }
+        }
+    }
+    #killUnhealthy(sess, reason) {
+        if (sess.unhealthyKilled)
+            return;
+        sess.unhealthyKilled = true;
+        const key = sess[this.#keyField];
+        log(`${this.#logTag} UNHEALTHY ${this.#keyField}=${key} pid=${sess.pid} — ${reason}; killing for respawn`);
+        if (this._sessions.get(key) === sess)
+            this._sessions.delete(key);
+        if (sess.idleTimer) {
+            clearTimeout(sess.idleTimer);
+            sess.idleTimer = null;
+        }
+        try {
+            sess.child.stdin.end();
+        }
+        catch {
+        }
+        try {
+            process.kill(sess.pid, 'SIGTERM');
+        }
+        catch {
+        }
+        setTimeout(() => {
+            try {
+                process.kill(sess.pid, 'SIGKILL');
+            }
+            catch {
+            }
+        }, STOP_GRACE_MS);
+    }
+    #evictLru() {
+        let oldestKey = null;
+        let oldest = Infinity;
+        for (const [k, s] of this._sessions.entries()) {
+            if (s.lastTouchedAt < oldest) {
+                oldest = s.lastTouchedAt;
+                oldestKey = k;
+            }
+        }
+        if (!oldestKey)
+            return false;
+        const s = this._sessions.get(oldestKey);
+        log(`${this.#logTag} evicting lru ${this.#keyField}=${oldestKey} pid=${s.pid}`);
+        if (s.idleTimer) {
+            clearTimeout(s.idleTimer);
+            s.idleTimer = null;
+        }
+        try {
+            s.child.stdin.end();
+        }
+        catch {
+        }
+        this._sessions.delete(oldestKey);
+        return true;
+    }
+    _rememberDedup(key) {
+        if (this.#dedupSet.has(key))
+            return false;
+        this.#dedupSet.add(key);
+        this.#dedupQueue.push(key);
+        while (this.#dedupQueue.length > this.#DEDUP_MAX) {
+            const old = this.#dedupQueue.shift();
+            if (old !== undefined)
+                this.#dedupSet.delete(old);
+        }
+        return true;
+    }
+    _forgetDedup(key) {
+        if (!this.#dedupSet.delete(key))
+            return;
+        const idx = this.#dedupQueue.indexOf(key);
+        if (idx >= 0)
+            this.#dedupQueue.splice(idx, 1);
+    }
+    async stopForAgent(agentId) {
+        if (!agentId)
+            return { count: 0, inflight: [] };
+        const victims = Array.from(this._sessions.values()).filter((s) => s.agentId === agentId);
+        if (victims.length === 0)
+            return { count: 0, inflight: [] };
+        for (const sess of victims) {
+            if (sess.idleTimer) {
+                clearTimeout(sess.idleTimer);
+                sess.idleTimer = null;
+            }
+            try {
+                sess.child.stdin.end();
+            }
+            catch {
+            }
+            try {
+                process.kill(sess.pid, 'SIGTERM');
+            }
+            catch {
+            }
+        }
+        log(`${this.#logTag} stopForAgent: agent=${agentId.slice(0, 8)} signalled ${victims.length} session(s) — SIGTERM`);
+        setTimeout(() => {
+            for (const sess of victims) {
+                try {
+                    process.kill(sess.pid, 0);
+                    try {
+                        process.kill(sess.pid, 'SIGKILL');
+                    }
+                    catch {
+                    }
+                }
+                catch {
+                }
+            }
+        }, STOP_GRACE_MS).unref?.();
+        const inflight = victims
+            .filter((s) => s.ticketId)
+            .map((s) => ({ ticketId: s.ticketId, role: s.role || '' }));
+        return { count: victims.length, inflight };
+    }
+    async stop() {
+        if (this.#healthTimer) {
+            clearInterval(this.#healthTimer);
+            this.#healthTimer = null;
+        }
+        const sessions = Array.from(this._sessions.values());
+        for (const sess of sessions) {
+            if (sess.idleTimer) {
+                clearTimeout(sess.idleTimer);
+                sess.idleTimer = null;
+            }
+            try {
+                sess.child.stdin.end();
+            }
+            catch {
+            }
+            try {
+                process.kill(sess.pid, 'SIGTERM');
+            }
+            catch {
+            }
+        }
+        if (sessions.length === 0) {
+            this._sessions.clear();
+            return;
+        }
+        await new Promise((r) => setTimeout(r, STOP_GRACE_MS));
+        for (const sess of sessions) {
+            try {
+                process.kill(sess.pid, 'SIGKILL');
+            }
+            catch {
+            }
+        }
+        this._sessions.clear();
+        log(`${this.constructor.name} stopped (terminated ${sessions.length} sessions)`);
+    }
+}
+//# sourceMappingURL=base-session-manager.js.map