chapterhouse 0.3.1 → 0.3.3

package/dist/copilot/orchestrator.test.js

@@ -98,6 +98,7 @@ async function loadOrchestratorModule(t, overrides = {}) {
             { slug: "coder", name: "Kaylee", model: "claude-sonnet-4.6" },
         ],
         sendResult: "Finished successfully",
+        taskEvents: new Map(),
         ...overrides,
     };
     const client = createFakeClient(state);
@@ -181,8 +182,17 @@ async function loadOrchestratorModule(t, overrides = {}) {
                     get: () => undefined,
                     all: () => [],
                 }),
+                transaction: (fn) => fn,
             }),
             bumpProjectLastUsed: (_projectRoot) => { },
+            appendTaskEvent: (taskId, kind, toolName, summary) => {
+                const seq = (state.taskEvents.get(taskId)?.length ?? 0) + 1;
+                const ev = { id: seq, taskId, seq, ts: Date.now(), kind, toolName, summary };
+                if (!state.taskEvents.has(taskId))
+                    state.taskEvents.set(taskId, []);
+                state.taskEvents.get(taskId).push(ev);
+                return ev;
+            },
         },
     });
     t.mock.module("./episode-writer.js", {
@@ -626,4 +636,238 @@ test("S5-01: subagent.failed event updates agent_tasks status to error", async (
     assert.ok(JSON.stringify(errorWrite.args).includes("subagent-call-003"), "UPDATE must target the correct task_id");
     state.pendingReject?.(new Error("test teardown"));
 });
+// ---------------------------------------------------------------------------
+// REGRESSION: #35 — per-session isolation
+// This test would have caught the original bug. With a global shared queue,
+// session B's message would queue behind session A's blocking turn and the
+// Promise.race would time out. With per-session queues, session B completes
+// independently.
+// ---------------------------------------------------------------------------
+test("regression #35: session A blocking does not delay session B (concurrent sessions)", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        config: { copilotModel: "claude-sonnet-4.6", selfEditEnabled: false, squadEnabled: true },
+        sendResult: "__PENDING__", // session A will block in sendAndWait
+    });
+    await orchestrator.initOrchestrator(client);
+    // Send to session A (project /project/a) — parks because sendResult is __PENDING__
+    const sessionACallbacks = [];
+    orchestrator.sendToOrchestrator("slow request to project A", { type: "web", connectionId: "conn-a", projectPath: "/project/a" }, (text, done) => sessionACallbacks.push({ text, done }));
+    // Yield to event loop so session A's drain loop runs and parks in sendAndWait
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    // Now session A is blocked inside sendAndWait. Switch sendResult so session B
+    // gets a fast response. session A's pending reject is still captured in its closure.
+    state.sendResult = "session B complete";
+    // Send to session B (different project) — must complete without waiting for session A
+    const sessionBDone = new Promise((resolve) => {
+        orchestrator.sendToOrchestrator("quick request to project B", { type: "web", connectionId: "conn-b", projectPath: "/project/b" }, (text, done) => {
+            if (done)
+                resolve(text);
+        });
+    });
+    // Session B must respond before the deadline (session A is still blocked indefinitely)
+    const result = await Promise.race([
+        sessionBDone,
+        new Promise((_, reject) => setTimeout(() => reject(new Error("session B was blocked by session A — global queue bug reproduced")), 300)),
+    ]);
+    assert.equal(result, "session B complete", "session B must resolve independently of blocked session A");
+    assert.equal(sessionACallbacks.length, 0, "session A must still be pending (no response yet)");
+    // Clean up: reject session A's pending promise so the test can finish
+    state.pendingReject?.(new Error("test teardown"));
+    await new Promise((resolve) => setTimeout(resolve, 10));
+});
+// ---------------------------------------------------------------------------
+// #81 — task spawn args (name/description) must win over SDK agent_type fields
+// Root cause: subagent.started only carries agent_type boilerplate. The actual
+// spawn params (name, description) arrive earlier via tool.execution_start for
+// toolName === "task". We stash them keyed by toolCallId and prefer them in the
+// INSERT so the worker tab shows "kaylee" instead of "general-purpose".
+// ---------------------------------------------------------------------------
+test("#81: tool.execution_start stash + subagent.started → agent_tasks uses spawn name/description", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        sendResult: "__PENDING__",
+    });
+    await orchestrator.initOrchestrator(client);
+    orchestrator.sendToOrchestrator("dispatch a worker", { type: "background" }, () => { });
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    assert.ok(state.lastSession, "FakeSession must have been created");
+    // Step 1: emit tool.execution_start for a "task" call with spawn parameters
+    state.lastSession.emit("tool.execution_start", {
+        toolName: "task",
+        toolCallId: "tc-spawn-1",
+        arguments: { name: "kaylee", description: "🔧 Kaylee: test spawn" },
+    });
+    // Step 2: emit subagent.started with the same toolCallId — SDK only knows agent_type details
+    state.lastSession.emit("subagent.started", {
+        toolCallId: "tc-spawn-1",
+        agentName: "general-purpose",
+        agentDisplayName: "General Purpose Agent",
+        agentDescription: "Full-capability agent boilerplate",
+    });
+    const insertWrite = state.dbWrites.find((w) => w.sql.includes("INSERT") && w.sql.includes("agent_tasks"));
+    assert.ok(insertWrite, "subagent.started must INSERT a row into agent_tasks");
+    const argsJson = JSON.stringify(insertWrite.args);
+    assert.ok(argsJson.includes("kaylee"), `agent_slug must be "kaylee" but got: ${argsJson}`);
+    assert.ok(argsJson.includes("🔧 Kaylee: test spawn"), `description must be spawn description but got: ${argsJson}`);
+    assert.ok(!argsJson.includes("general-purpose"), `agent_slug must NOT fall back to "general-purpose" when spawn name is available`);
+    state.pendingReject?.(new Error("test teardown"));
+});
+test("#81 fallback: subagent.started with no prior tool.execution_start uses agentName/agentDescription", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        sendResult: "__PENDING__",
+    });
+    await orchestrator.initOrchestrator(client);
+    orchestrator.sendToOrchestrator("dispatch a worker", { type: "background" }, () => { });
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    assert.ok(state.lastSession, "FakeSession must have been created");
+    // No tool.execution_start emitted — subagent.started fires cold
+    state.lastSession.emit("subagent.started", {
+        toolCallId: "tc-no-spawn",
+        agentName: "general-purpose",
+        agentDisplayName: "General Purpose Agent",
+        agentDescription: "Full-capability agent boilerplate",
+    });
+    const insertWrite = state.dbWrites.find((w) => w.sql.includes("INSERT") && w.sql.includes("agent_tasks"));
+    assert.ok(insertWrite, "subagent.started must still INSERT a row without spawn args");
+    const argsJson = JSON.stringify(insertWrite.args);
+    assert.ok(argsJson.includes("general-purpose"), `agent_slug must fall back to agentName ("general-purpose") when no spawn args: ${argsJson}`);
+    assert.ok(argsJson.includes("Full-capability agent boilerplate"), `description must fall back to agentDescription: ${argsJson}`);
+    state.pendingReject?.(new Error("test teardown"));
+});
+test("#81: activity callback receives resolved agentSlug from spawn args (SSE live path)", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        sendResult: "__PENDING__",
+    });
+    await orchestrator.initOrchestrator(client);
+    const activityEvents = [];
+    orchestrator.sendToOrchestrator("dispatch a worker", { type: "background" }, () => { }, undefined, // no attachments
+    (event) => { activityEvents.push(event); });
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    assert.ok(state.lastSession, "FakeSession must have been created");
+    // Stash spawn args via tool.execution_start
+    state.lastSession.emit("tool.execution_start", {
+        toolName: "task",
+        toolCallId: "tc-activity-1",
+        arguments: { name: "kaylee", description: "🔧 Kaylee: test spawn" },
+    });
+    // SDK fires subagent.started with boilerplate agent_type fields
+    state.lastSession.emit("subagent.started", {
+        toolCallId: "tc-activity-1",
+        agentName: "general-purpose",
+        agentDisplayName: "General Purpose Agent",
+        agentDescription: "Full-capability agent boilerplate",
+    });
+    const startedEvent = activityEvents.find((e) => e.kind === "subagent_started");
+    assert.ok(startedEvent, "onActivity must have been called with a subagent_started event");
+    assert.equal(startedEvent.agentSlug, "kaylee", `agentSlug in activity event must be "kaylee" (spawn name), got: ${startedEvent.agentSlug}`);
+    assert.ok(String(startedEvent.agentDescription).includes("🔧 Kaylee"), `agentDescription in activity event must use spawn description, got: ${startedEvent.agentDescription}`);
+    state.pendingReject?.(new Error("test teardown"));
+});
+// ---------------------------------------------------------------------------
+// #86: Nested tool-call events streamed to /workers detail pane
+// ---------------------------------------------------------------------------
+test("#86: tool.execution_start with parentToolCallId matching active subagent calls appendTaskEvent", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        sendResult: "__PENDING__",
+    });
+    await orchestrator.initOrchestrator(client);
+    orchestrator.sendToOrchestrator("dispatch kaylee", { type: "background" }, () => { });
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    assert.ok(state.lastSession, "FakeSession must have been created");
+    // Register the subagent task via subagent.started so activeSubagentTaskIds is populated
+    state.lastSession.emit("subagent.started", {
+        toolCallId: "subagent-task-001",
+        agentName: "kaylee",
+        agentDisplayName: "Kaylee — Backend Dev",
+        agentDescription: "Fix the streaming gap",
+    });
+    // Fire a nested tool.execution_start with parentToolCallId pointing to the subagent
+    state.lastSession.emit("tool.execution_start", {
+        toolCallId: "nested-call-001",
+        toolName: "bash",
+        parentToolCallId: "subagent-task-001",
+        arguments: { command: "npm run build" },
+    });
+    const events = state.taskEvents.get("subagent-task-001") ?? [];
+    assert.equal(events.length, 1, "appendTaskEvent must have been called once for the nested tool start");
+    assert.equal(events[0].kind, "tool_start");
+    assert.equal(events[0].toolName, "bash");
+    assert.equal(events[0].summary, "npm run build");
+    state.pendingReject?.(new Error("test teardown"));
+});
+test("#86: tool.execution_start with parentToolCallId NOT in active subagents is ignored", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        sendResult: "__PENDING__",
+    });
+    await orchestrator.initOrchestrator(client);
+    orchestrator.sendToOrchestrator("run something", { type: "background" }, () => { });
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    assert.ok(state.lastSession, "FakeSession must have been created");
+    // No subagent.started fired — activeSubagentTaskIds is empty
+    state.lastSession.emit("tool.execution_start", {
+        toolCallId: "nested-call-002",
+        toolName: "bash",
+        parentToolCallId: "unknown-parent",
+        arguments: { command: "echo hi" },
+    });
+    const events = state.taskEvents.get("unknown-parent") ?? [];
+    assert.equal(events.length, 0, "appendTaskEvent must NOT be called when parentToolCallId is not a known subagent");
+    state.pendingReject?.(new Error("test teardown"));
+});
+test("#86: tool.execution_complete with parentToolCallId calls appendTaskEvent with tool_complete", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        sendResult: "__PENDING__",
+    });
+    await orchestrator.initOrchestrator(client);
+    orchestrator.sendToOrchestrator("dispatch agent", { type: "background" }, () => { });
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    assert.ok(state.lastSession, "FakeSession must have been created");
+    state.lastSession.emit("subagent.started", {
+        toolCallId: "subagent-task-002",
+        agentName: "zoe",
+        agentDisplayName: "Zoe — QA",
+        agentDescription: "Run tests",
+    });
+    state.lastSession.emit("tool.execution_complete", {
+        toolCallId: "nested-call-003",
+        parentToolCallId: "subagent-task-002",
+        success: true,
+        result: { content: "All tests passed" },
+    });
+    const events = state.taskEvents.get("subagent-task-002") ?? [];
+    assert.equal(events.length, 1, "appendTaskEvent must have been called for tool_complete");
+    assert.equal(events[0].kind, "tool_complete");
+    assert.ok(String(events[0].summary).includes("All tests passed"), `summary must include result content, got: ${events[0].summary}`);
+    state.pendingReject?.(new Error("test teardown"));
+});
+test("#86: subagent.completed removes task from activeSubagentTaskIds — subsequent nested events ignored", async (t) => {
+    const { orchestrator, state, client } = await loadOrchestratorModule(t, {
+        sendResult: "__PENDING__",
+    });
+    await orchestrator.initOrchestrator(client);
+    orchestrator.sendToOrchestrator("dispatch agent", { type: "background" }, () => { });
+    await new Promise((resolve) => setTimeout(resolve, 10));
+    assert.ok(state.lastSession, "FakeSession must have been created");
+    state.lastSession.emit("subagent.started", {
+        toolCallId: "subagent-task-003",
+        agentName: "wash",
+        agentDisplayName: "Wash",
+        agentDescription: "UI work",
+    });
+    // Complete the subagent — removes from activeSubagentTaskIds
+    state.lastSession.emit("subagent.completed", {
+        toolCallId: "subagent-task-003",
+        agentName: "wash",
+        agentDisplayName: "Wash",
+    });
+    // Nested event arriving after completion must be ignored
+    state.lastSession.emit("tool.execution_start", {
+        toolCallId: "late-tool-call",
+        toolName: "view",
+        parentToolCallId: "subagent-task-003",
+        arguments: { path: "/some/file" },
+    });
+    const events = state.taskEvents.get("subagent-task-003") ?? [];
+    assert.equal(events.length, 0, "No task events must be recorded after subagent completes");
+    state.pendingReject?.(new Error("test teardown"));
+});
 //# sourceMappingURL=orchestrator.test.js.map

package/dist/copilot/session-manager.js

@@ -0,0 +1,337 @@
+// ---------------------------------------------------------------------------
+// SessionManager — per-session queue, lifecycle, and SDK session holder
+// SessionRegistry — owns all active sessions; handles TTL + LRU + explicit eviction
+//
+// Eviction strategy (Hybrid):
+//   1. Explicit close  — caller calls registry.close(sessionKey, "explicit-close")
+//   2. TTL fallback    — idle sessions evicted after CHAPTERHOUSE_SESSION_IDLE_TTL_MS
+//   3. LRU cap         — when maxActive is reached, evict least-recently-used idle session
+//
+// Invariant: never evict a session that is mid-turn or has queued messages.
+//   canEvict = !isProcessing && queueDepth === 0
+//
+// Config:
+//   CHAPTERHOUSE_SESSION_IDLE_TTL_MS  (default: 1 800 000 ms = 30 min)
+//   CHAPTERHOUSE_SESSION_MAX_ACTIVE   (default: 20)
+// ---------------------------------------------------------------------------
+import { childLogger } from "../util/logger.js";
+const log = childLogger("session-manager");
+// ---------------------------------------------------------------------------
+// Env-configurable eviction parameters
+// ---------------------------------------------------------------------------
+const DEFAULT_SESSION_IDLE_TTL_MS = 1_800_000; // 30 min
+export const SESSION_IDLE_TTL_MS = (() => {
+    const env = process.env.CHAPTERHOUSE_SESSION_IDLE_TTL_MS;
+    if (env) {
+        const parsed = parseInt(env, 10);
+        if (!isNaN(parsed) && parsed > 0)
+            return parsed;
+    }
+    return DEFAULT_SESSION_IDLE_TTL_MS;
+})();
+const DEFAULT_SESSION_MAX_ACTIVE = 20;
+export const SESSION_MAX_ACTIVE = (() => {
+    const env = process.env.CHAPTERHOUSE_SESSION_MAX_ACTIVE;
+    if (env) {
+        const parsed = parseInt(env, 10);
+        if (!isNaN(parsed) && parsed > 0)
+            return parsed;
+    }
+    return DEFAULT_SESSION_MAX_ACTIVE;
+})();
+// ---------------------------------------------------------------------------
+// SessionManager — owns one session key
+// ---------------------------------------------------------------------------
+export class SessionManager {
+    worker;
+    sessionFactory;
+    sessionKey;
+    _queue = [];
+    _processing = false;
+    _session;
+    _sessionCreatePromise;
+    _currentModel;
+    _recentTiers = [];
+    _lastActivityAt = Date.now();
+    /** Set by registry.close() when the session is busy at close time. The drain loop
+     * honors this after the queue fully empties — evicting without violating the
+     * never-evict-mid-turn invariant. */
+    _pendingClose = false;
+    _onPendingCloseEvict;
+    constructor(sessionKey, worker, sessionFactory) {
+        this.worker = worker;
+        this.sessionFactory = sessionFactory;
+        this.sessionKey = sessionKey;
+    }
+    // ── Observation surface ──────────────────────────────────────────────────
+    get isProcessing() {
+        return this._processing;
+    }
+    get queueDepth() {
+        return this._queue.length;
+    }
+    /** True when the session can be safely evicted. */
+    get canEvict() {
+        return !this._processing && this._queue.length === 0;
+    }
+    get lastActivityAt() {
+        return this._lastActivityAt;
+    }
+    /** True when an explicit close was requested while the session was busy. */
+    get pendingClose() {
+        return this._pendingClose;
+    }
+    /**
+     * Mark this session for deferred eviction. Called by SessionRegistry.close()
+     * when the session is mid-turn or has queued messages. The drain loop calls
+     * `onEvict` after the queue fully empties.
+     */
+    setPendingClose(onEvict) {
+        this._pendingClose = true;
+        this._onPendingCloseEvict = onEvict;
+    }
+    // ── Session and model state (for orchestrator.ts) ────────────────────────
+    get session() {
+        return this._session;
+    }
+    set session(s) {
+        this._session = s;
+    }
+    get currentModel() {
+        return this._currentModel;
+    }
+    set currentModel(m) {
+        this._currentModel = m;
+    }
+    get recentTiers() {
+        return this._recentTiers;
+    }
+    get sessionCreatePromise() {
+        return this._sessionCreatePromise;
+    }
+    set sessionCreatePromise(p) {
+        this._sessionCreatePromise = p;
+    }
+    addRecentTier(tier) {
+        this._recentTiers.push(tier);
+        if (this._recentTiers.length > 5) {
+            this._recentTiers = this._recentTiers.slice(-5);
+        }
+    }
+    // ── Queue ────────────────────────────────────────────────────────────────
+    enqueue(item) {
+        this._queue.push(item);
+        this._lastActivityAt = Date.now();
+        const depth = this._queue.length;
+        if (depth > 1) {
+            log.debug({ sessionKey: this.sessionKey, depth }, "session.queue.depth");
+        }
+        void this.drain();
+    }
+    /**
+     * Drain the queue one item at a time.
+     * Guarantees per-session FIFO ordering and one concurrent turn per session.
+     */
+    async drain() {
+        if (this._processing)
+            return;
+        this._processing = true;
+        while (this._queue.length > 0) {
+            const item = this._queue.shift();
+            const start = Date.now();
+            log.info({ sessionKey: this.sessionKey, sourceChannel: item.sourceChannel }, "session.turn.started");
+            try {
+                const result = await this.worker(item, this);
+                const durationMs = Date.now() - start;
+                log.info({ sessionKey: this.sessionKey, durationMs }, "session.turn.finished");
+                item.resolve(result);
+            }
+            catch (err) {
+                const durationMs = Date.now() - start;
+                log.warn({ sessionKey: this.sessionKey, durationMs, err: err instanceof Error ? err.message : String(err) }, "session.turn.failed");
+                item.reject(err);
+            }
+            this._lastActivityAt = Date.now();
+        }
+        this._processing = false;
+        // Honor deferred explicit-close: evict now that the queue is empty.
+        if (this._pendingClose && this._queue.length === 0) {
+            log.info({ sessionKey: this.sessionKey }, "session.pendingClose.evicting");
+            this._onPendingCloseEvict?.();
+        }
+    }
+    // ── Session lifecycle ────────────────────────────────────────────────────
+    /** Ensure the CopilotSession exists, creating/resuming if needed. Concurrency-safe. */
+    async ensureSession() {
+        if (this._session)
+            return this._session;
+        if (this._sessionCreatePromise)
+            return this._sessionCreatePromise;
+        const projectRoot = this.sessionKey.startsWith("project:")
+            ? this.sessionKey.slice("project:".length)
+            : undefined;
+        const promise = this.sessionFactory(this.sessionKey, projectRoot);
+        this._sessionCreatePromise = promise;
+        try {
+            const session = await promise;
+            this._session = session;
+            return session;
+        }
+        finally {
+            this._sessionCreatePromise = undefined;
+        }
+    }
+    /** Invalidate the cached session so the next ensureSession() creates a fresh one. */
+    invalidateSession() {
+        this._session = undefined;
+        this._sessionCreatePromise = undefined;
+    }
+    /** Reject all queued messages without evicting the session. Returns count drained. */
+    cancelQueued() {
+        const count = this._queue.length;
+        while (this._queue.length > 0) {
+            const item = this._queue.shift();
+            item.reject(new Error("Cancelled"));
+        }
+        return count;
+    }
+    /** Abort the in-flight SDK request on this session. Returns true if abort was sent. */
+    async abortCurrentTurn() {
+        if (!this._session || !this._processing)
+            return false;
+        try {
+            await this._session.abort();
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Evict this session: reject queued items and disconnect the SDK session.
+     * Safe to call even when not processing (canEvict check is the caller's responsibility).
+     */
+    async evict(reason) {
+        // Reject any messages still in the queue
+        while (this._queue.length > 0) {
+            const item = this._queue.shift();
+            item.reject(new Error(`Session evicted: ${reason}`));
+        }
+        // Disconnect the SDK session
+        if (this._session) {
+            try {
+                await this._session.disconnect();
+            }
+            catch {
+                // best effort
+            }
+            this._session = undefined;
+        }
+    }
+}
+// ---------------------------------------------------------------------------
+// SessionRegistry — owns all sessions, drives eviction
+// ---------------------------------------------------------------------------
+export class SessionRegistry {
+    options;
+    createManager;
+    managers = new Map();
+    evictionTimer;
+    constructor(options, createManager) {
+        this.options = options;
+        this.createManager = createManager;
+    }
+    /**
+     * Return the SessionManager for the given key, creating one if needed.
+     * Triggers LRU eviction if maxActive is reached.
+     */
+    getOrCreate(sessionKey) {
+        const existing = this.managers.get(sessionKey);
+        if (existing)
+            return existing;
+        if (this.managers.size >= this.options.maxActive) {
+            this.evictLRU();
+        }
+        const manager = this.createManager(sessionKey);
+        this.managers.set(sessionKey, manager);
+        log.info({ sessionKey, activeSessions: this.managers.size }, "session.created");
+        return manager;
+    }
+    get(sessionKey) {
+        return this.managers.get(sessionKey);
+    }
+    getAll() {
+        return this.managers;
+    }
+    size() {
+        return this.managers.size;
+    }
+    /**
+     * Explicitly close a session (e.g., browser tab closed).
+     * If busy (mid-turn or queued messages), sets _pendingClose on the manager so the
+     * drain loop evicts it as soon as the queue empties — honoring the explicit-close
+     * intent without violating the never-evict-mid-turn invariant.
+     */
+    close(sessionKey, reason) {
+        const manager = this.managers.get(sessionKey);
+        if (!manager)
+            return;
+        if (!manager.canEvict) {
+            log.info({ sessionKey, reason }, "session.close.deferred — session is busy; will evict when queue drains");
+            manager.setPendingClose(() => {
+                this.managers.delete(sessionKey);
+                void manager.evict(reason);
+                log.info({ sessionKey, reason }, "session.evicted (deferred)");
+            });
+            return;
+        }
+        this.managers.delete(sessionKey);
+        void manager.evict(reason);
+        log.info({ sessionKey, reason }, "session.evicted");
+    }
+    /** Start the periodic TTL eviction scan. */
+    startEvictionTimer() {
+        if (this.evictionTimer)
+            return;
+        // Scan at most once per minute, or half the TTL interval (whichever is shorter)
+        const intervalMs = Math.min(this.options.idleTtlMs / 2, 60_000);
+        this.evictionTimer = setInterval(() => this.runTtlEviction(), intervalMs);
+    }
+    stopEvictionTimer() {
+        if (this.evictionTimer) {
+            clearInterval(this.evictionTimer);
+            this.evictionTimer = undefined;
+        }
+    }
+    runTtlEviction() {
+        const now = Date.now();
+        for (const [sessionKey, manager] of [...this.managers.entries()]) {
+            if (manager.canEvict && now - manager.lastActivityAt > this.options.idleTtlMs) {
+                const idleMs = now - manager.lastActivityAt;
+                this.managers.delete(sessionKey);
+                void manager.evict("ttl-expired");
+                log.info({ sessionKey, reason: "ttl-expired", idleMs }, "session.evicted");
+            }
+        }
+    }
+    evictLRU() {
+        const evictable = [...this.managers.entries()]
+            .filter(([, m]) => m.canEvict)
+            .sort(([, a], [, b]) => a.lastActivityAt - b.lastActivityAt);
+        if (evictable.length === 0) {
+            log.warn({ size: this.managers.size, max: this.options.maxActive }, "At max active sessions and no idle sessions available for LRU eviction");
+            return;
+        }
+        const [sessionKey, manager] = evictable[0];
+        this.managers.delete(sessionKey);
+        void manager.evict("lru-bumped");
+        log.info({ sessionKey, reason: "lru-bumped" }, "session.evicted");
+    }
+    /** Shut down all sessions. Stops the eviction timer and disconnects every session. */
+    async shutdown() {
+        this.stopEvictionTimer();
+        await Promise.allSettled([...this.managers.values()].map((m) => m.evict("explicit-close")));
+        this.managers.clear();
+    }
+}
+//# sourceMappingURL=session-manager.js.map