chapterhouse 0.3.0 → 0.3.2

package/dist/copilot/orchestrator.test.js

@@ -619,11 +619,50 @@ test("S5-01: subagent.failed event updates agent_tasks status to error", async (
         toolCallId: "subagent-call-003",
         agentName: "Zoe",
         agentDisplayName: "Zoe — QA",
-        error: "Timeout after 600s",
+        error: "Timeout after 1800s",
     });
     const errorWrite = state.dbWrites.find((w) => w.sql.includes("UPDATE") && w.sql.includes("agent_tasks") && w.sql.includes("error"));
     assert.ok(errorWrite, "subagent.failed must UPDATE agent_tasks to error status");
     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));
+});
 //# sourceMappingURL=orchestrator.test.js.map

package/dist/copilot/session-manager.js

@@ -0,0 +1,307 @@
+// ---------------------------------------------------------------------------
+// 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();
+    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;
+    }
+    // ── 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;
+    }
+    // ── 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).
+     * Deferred (with warning) if the session is currently busy.
+     */
+    close(sessionKey, reason) {
+        const manager = this.managers.get(sessionKey);
+        if (!manager)
+            return;
+        if (!manager.canEvict) {
+            log.warn({ sessionKey, reason }, "Eviction deferred — session is mid-turn or has queued messages");
+            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

package/dist/copilot/session-manager.test.js

@@ -0,0 +1,292 @@
+// ---------------------------------------------------------------------------
+// Tests for SessionManager and SessionRegistry
+// ---------------------------------------------------------------------------
+import assert from "node:assert/strict";
+import test from "node:test";
+import { SessionManager, SessionRegistry, } from "./session-manager.js";
+function makeFakeSession() {
+    const tracker = {
+        disconnectCalls: 0,
+        abortCalls: 0,
+        session: null,
+    };
+    tracker.session = {
+        sessionId: "fake-" + Math.random().toString(36).slice(2),
+        async disconnect() { tracker.disconnectCalls++; },
+        async abort() { tracker.abortCalls++; },
+        on() { return () => { }; },
+        async sendAndWait() { return { data: { content: "ok" } }; },
+        async setModel() { },
+        getState() { return "connected"; },
+    };
+    return tracker;
+}
+function factory(session) {
+    return async () => session;
+}
+function makeDeferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => { resolve = res; reject = rej; });
+    const item = {
+        prompt: "test prompt",
+        callback: () => { },
+        sessionKey: "default",
+        resolve,
+        reject,
+    };
+    return { item, promise, resolve, reject };
+}
+// ---------------------------------------------------------------------------
+// SessionManager tests
+// ---------------------------------------------------------------------------
+test("SessionManager: canEvict is true when idle with empty queue", () => {
+    const { session } = makeFakeSession();
+    const manager = new SessionManager("default", async () => "ok", factory(session));
+    assert.equal(manager.isProcessing, false);
+    assert.equal(manager.queueDepth, 0);
+    assert.equal(manager.canEvict, true);
+});
+test("SessionManager: canEvict is false while processing, true after", async () => {
+    const { session } = makeFakeSession();
+    let unblock;
+    const worker = () => new Promise((r) => { unblock = () => r("done"); });
+    const manager = new SessionManager("default", worker, factory(session));
+    const { item } = makeDeferred();
+    manager.enqueue(item);
+    await new Promise((r) => setTimeout(r, 0));
+    assert.equal(manager.isProcessing, true, "should be processing after enqueue");
+    assert.equal(manager.canEvict, false, "must not evict while processing");
+    unblock();
+    await new Promise((r) => setTimeout(r, 0));
+    assert.equal(manager.isProcessing, false, "should be idle after worker completes");
+    assert.equal(manager.canEvict, true, "can evict once idle");
+});
+test("SessionManager: canEvict is false when queue has pending items", async () => {
+    const { session } = makeFakeSession();
+    let unblock;
+    const worker = () => new Promise((r) => { unblock = () => r("done"); });
+    const manager = new SessionManager("default", worker, factory(session));
+    const { item: i1 } = makeDeferred();
+    const { item: i2 } = makeDeferred();
+    manager.enqueue(i1);
+    manager.enqueue(i2);
+    await new Promise((r) => setTimeout(r, 0));
+    assert.equal(manager.queueDepth, 1, "second item still queued");
+    assert.equal(manager.canEvict, false, "must not evict with queued items");
+    unblock();
+    await new Promise((r) => setTimeout(r, 5));
+    assert.equal(manager.queueDepth, 0, "queue should drain");
+    // Clean up: unblock second (which completes instantly via the same worker closure)
+});
+test("SessionManager: cancelQueued drains pending queue items and rejects them", async () => {
+    const { session } = makeFakeSession();
+    let unblock;
+    const worker = () => new Promise((r) => { unblock = () => r("first"); });
+    const manager = new SessionManager("default", worker, factory(session));
+    const { item: i1 } = makeDeferred();
+    const { item: i2, promise: p2 } = makeDeferred();
+    const { item: i3, promise: p3 } = makeDeferred();
+    manager.enqueue(i1);
+    manager.enqueue(i2);
+    manager.enqueue(i3);
+    await new Promise((r) => setTimeout(r, 0));
+    assert.equal(manager.queueDepth, 2, "two items queued while first processes");
+    const drained = manager.cancelQueued();
+    assert.equal(drained, 2, "two queued items should be cancelled");
+    await assert.rejects(p2, /Cancelled/, "item2 should reject with Cancelled");
+    await assert.rejects(p3, /Cancelled/, "item3 should reject with Cancelled");
+    unblock();
+    await new Promise((r) => setTimeout(r, 0));
+});
+test("SessionManager: evict disconnects session and rejects queued items", async () => {
+    const t1 = makeFakeSession();
+    let unblock;
+    const worker = () => new Promise((r) => { unblock = () => r("ok"); });
+    const manager = new SessionManager("default", worker, factory(t1.session));
+    const { item: i1 } = makeDeferred();
+    const { item: i2, promise: p2 } = makeDeferred();
+    manager.enqueue(i1);
+    manager.enqueue(i2);
+    await new Promise((r) => setTimeout(r, 0));
+    // Evict: rejects queued items and disconnects session
+    const evictDone = manager.evict("explicit-close");
+    await assert.rejects(p2, /evicted/, "queued item should be rejected with evicted");
+    await evictDone;
+    assert.equal(t1.disconnectCalls, 0, "session not yet created — no disconnect needed");
+    // Now with a primed session
+    const t2 = makeFakeSession();
+    const manager2 = new SessionManager("s2", async () => "ok", factory(t2.session));
+    await manager2.ensureSession();
+    await manager2.evict("explicit-close");
+    assert.equal(t2.disconnectCalls, 1, "session should be disconnected on evict");
+    unblock();
+    await new Promise((r) => setTimeout(r, 0));
+});
+test("SessionManager: abortCurrentTurn returns false when not processing", async () => {
+    const { session } = makeFakeSession();
+    const manager = new SessionManager("default", async () => "ok", factory(session));
+    await manager.ensureSession();
+    const aborted = await manager.abortCurrentTurn();
+    assert.equal(aborted, false);
+});
+test("SessionManager: abortCurrentTurn calls session.abort() when processing", async () => {
+    const t = makeFakeSession();
+    const worker = async (_item, mgr) => {
+        await mgr.ensureSession();
+        return new Promise(() => { }); // park forever
+    };
+    const manager = new SessionManager("default", worker, factory(t.session));
+    const { item } = makeDeferred();
+    manager.enqueue(item);
+    await new Promise((r) => setTimeout(r, 0));
+    assert.equal(manager.isProcessing, true, "manager must be processing");
+    const aborted = await manager.abortCurrentTurn();
+    assert.equal(aborted, true, "abortCurrentTurn should return true");
+    assert.equal(t.abortCalls, 1, "session.abort() must be called once");
+});
+test("SessionManager: addRecentTier caps at 5 entries", () => {
+    const { session } = makeFakeSession();
+    const manager = new SessionManager("default", async () => "ok", factory(session));
+    for (let i = 0; i < 8; i++)
+        manager.addRecentTier("fast");
+    assert.equal(manager.recentTiers.length, 5, "should cap at 5 recent tiers");
+});
+// ---------------------------------------------------------------------------
+// SessionRegistry tests
+// ---------------------------------------------------------------------------
+function makeRegistry(opts = {}) {
+    const { idleTtlMs = 60_000, maxActive = 10 } = opts;
+    const disconnectLog = [];
+    const registry = new SessionRegistry({ idleTtlMs, maxActive }, (sk) => {
+        const t = makeFakeSession();
+        // Instrument disconnect to capture key
+        const orig = t.session.disconnect.bind(t.session);
+        t.session.disconnect = async () => {
+            disconnectLog.push(sk);
+            await orig();
+        };
+        return new SessionManager(sk, async () => "ok", factory(t.session));
+    });
+    return { registry, disconnectLog };
+}
+test("SessionRegistry: getOrCreate returns same manager for same key", () => {
+    const { registry } = makeRegistry();
+    const m1 = registry.getOrCreate("default");
+    const m2 = registry.getOrCreate("default");
+    assert.ok(m1 instanceof SessionManager);
+    assert.equal(m1, m2, "same key returns same manager");
+    assert.equal(registry.size(), 1);
+});
+test("SessionRegistry: LRU eviction fires when at maxActive capacity", async () => {
+    const { registry, disconnectLog } = makeRegistry({ maxActive: 3, idleTtlMs: 60_000 });
+    // Create 3 sessions with staggered timestamps so LRU is deterministic
+    const m1 = registry.getOrCreate("s1");
+    await new Promise((r) => setTimeout(r, 2));
+    registry.getOrCreate("s2");
+    await new Promise((r) => setTimeout(r, 2));
+    registry.getOrCreate("s3");
+    // Prime s1's session so it gets disconnected
+    await m1.ensureSession();
+    assert.equal(registry.size(), 3);
+    // Adding a 4th should evict s1 (oldest lastActivityAt)
+    registry.getOrCreate("s4");
+    await new Promise((r) => setTimeout(r, 5));
+    assert.equal(registry.size(), 3, "size should remain at max");
+    assert.ok(disconnectLog.includes("s1"), "s1 (oldest) should be LRU-evicted");
+    assert.ok(!registry.get("s1"), "s1 should be removed from registry");
+});
+test("SessionRegistry: explicit close evicts an idle session", async () => {
+    const { registry, disconnectLog } = makeRegistry();
+    const m = registry.getOrCreate("my-session");
+    await m.ensureSession();
+    assert.equal(registry.size(), 1);
+    registry.close("my-session", "explicit-close");
+    await new Promise((r) => setTimeout(r, 5));
+    assert.equal(registry.size(), 0, "session should be removed");
+    assert.ok(disconnectLog.includes("my-session"), "session should be disconnected");
+});
+test("SessionRegistry: close is deferred when session is processing", async () => {
+    const { registry, disconnectLog } = makeRegistry();
+    let unblock;
+    // Replace the factory with a blocking one
+    const { registry: reg2, disconnectLog: dl2 } = (() => {
+        const log = [];
+        const r = new SessionRegistry({ idleTtlMs: 60_000, maxActive: 10 }, (sk) => {
+            const t = makeFakeSession();
+            t.session.disconnect = async () => { log.push(sk); };
+            const worker = () => new Promise((res) => { unblock = () => res("done"); });
+            return new SessionManager(sk, worker, factory(t.session));
+        });
+        return { registry: r, disconnectLog: log };
+    })();
+    const m = reg2.getOrCreate("busy");
+    const { item } = makeDeferred();
+    m.enqueue(item);
+    await new Promise((r) => setTimeout(r, 0));
+    assert.equal(m.isProcessing, true);
+    // close() should be deferred (session is busy)
+    reg2.close("busy", "explicit-close");
+    await new Promise((r) => setTimeout(r, 5));
+    assert.ok(reg2.get("busy"), "busy session must remain in registry");
+    assert.equal(dl2.length, 0, "disconnect must not fire while processing");
+    unblock();
+    await new Promise((r) => setTimeout(r, 5));
+});
+test("SessionRegistry: TTL eviction removes sessions idle beyond the TTL", async () => {
+    const SHORT_TTL = 40;
+    const { registry, disconnectLog } = makeRegistry({ idleTtlMs: SHORT_TTL });
+    const m = registry.getOrCreate("idle-session");
+    await m.ensureSession();
+    registry.startEvictionTimer();
+    // Wait past 3 × TTL — the eviction scan interval is min(TTL/2, 60s) = 20ms
+    await new Promise((r) => setTimeout(r, SHORT_TTL * 5));
+    registry.stopEvictionTimer();
+    assert.ok(disconnectLog.includes("idle-session"), "idle session must be evicted after TTL");
+    assert.ok(!registry.get("idle-session"), "idle session must be removed");
+});
+test("SessionRegistry: shutdown disconnects all sessions", async () => {
+    const { registry, disconnectLog } = makeRegistry();
+    for (const sk of ["a", "b", "c"]) {
+        const m = registry.getOrCreate(sk);
+        await m.ensureSession();
+    }
+    assert.equal(registry.size(), 3);
+    await registry.shutdown();
+    assert.equal(registry.size(), 0, "registry must be empty after shutdown");
+    assert.equal(disconnectLog.length, 3, "all sessions must be disconnected");
+});
+test("SessionRegistry: concurrent sessions process independently", async () => {
+    const completionOrder = [];
+    let unblockA;
+    const registry = new SessionRegistry({ idleTtlMs: 60_000, maxActive: 10 }, (sk) => {
+        const t = makeFakeSession();
+        const worker = async (_item, _mgr) => {
+            if (sk === "session-a") {
+                await new Promise((r) => { unblockA = r; });
+            }
+            completionOrder.push(sk);
+            return `${sk} done`;
+        };
+        return new SessionManager(sk, worker, factory(t.session));
+    });
+    const mA = registry.getOrCreate("session-a");
+    const mB = registry.getOrCreate("session-b");
+    const { item: iA, promise: pA } = makeDeferred();
+    const { item: iB, promise: pB } = makeDeferred();
+    mA.enqueue(iA);
+    mB.enqueue(iB);
+    // Session B should complete before session A (A is parked)
+    const resultB = await Promise.race([
+        pB,
+        new Promise((_, reject) => setTimeout(() => reject(new Error("session B was blocked by session A")), 200)),
+    ]);
+    assert.equal(resultB, "session-b done", "session B must complete independently");
+    assert.equal(completionOrder[0], "session-b", "session B must finish first");
+    assert.ok(mA.isProcessing, "session A should still be processing");
+    unblockA();
+    const resultA = await pA;
+    assert.equal(resultA, "session-a done");
+    assert.deepEqual(completionOrder, ["session-b", "session-a"]);
+});
+//# sourceMappingURL=session-manager.test.js.map

package/dist/copilot/system-message.js

@@ -1,5 +1,6 @@
 import { getExampleProjectPath } from "../home-path.js";
 export function getOrchestratorSystemMessage(opts) {
+    const versionBanner = opts?.version ? `\nYou are running inside chapterhouse v${opts.version}.\n` : "";
     const memoryBlock = opts?.memorySummary
         ? `\n## Memory\nYou have a persistent memory store. Here's what you currently remember:\n\n${opts.memorySummary}\n`
         : "\n## Memory\nYou have a persistent memory store. It's currently empty — use `remember` to start building it!\n";
@@ -25,7 +26,7 @@ This restriction does NOT apply to:
         : "";
     const osName = process.platform === "darwin" ? "macOS" : process.platform === "win32" ? "Windows" : "Linux";
     return `You are Chapterhouse, a team-level AI assistant for engineering teams running 24/7 on the user's machine (${osName}). You are the engineering team's always-on assistant.
-
+${versionBanner}
 ${userContextBlock}
 ## Your Architecture
 

package/dist/copilot/system-message.test.js

@@ -14,4 +14,12 @@ test("orchestrator prompt expands shorthand paths with the current home director
     assert.match(message, new RegExp(join(homedir(), "dev", "myapp").replace(/[.*+?^${}()|[\]\\]/g, "\\$&")));
     assert.doesNotMatch(message, /"~\/dev\/myapp"/);
 });
+test("orchestrator prompt includes chapterhouse version banner when version is provided", () => {
+    const message = getOrchestratorSystemMessage({ version: "1.2.3" });
+    assert.match(message, /chapterhouse v1\.2\.3/);
+});
+test("orchestrator prompt omits version banner when version is not provided", () => {
+    const message = getOrchestratorSystemMessage();
+    assert.doesNotMatch(message, /chapterhouse v\d/);
+});
 //# sourceMappingURL=system-message.test.js.map