mcp-coordinator 0.2.0 → 0.3.0

package/dist/cli/dashboard.js

@@ -1,14 +1,18 @@
 import { Command } from "commander";
-import { exec } from "child_process";
+import { spawn } from "child_process";
 export function createDashboardCommand() {
     return new Command("dashboard")
         .description("Open the real-time dashboard")
         .action(() => {
         const url = "http://localhost:3100/dashboard";
         console.log(`Dashboard: ${url}`);
-        const cmd = process.platform === "darwin"
-            ? `open "${url}"`
-            : `xdg-open "${url}" 2>/dev/null`;
-        exec(cmd, () => { });
+        // Use spawn with an argv array (no shell) so the URL is never
+        // interpolated into a shell command — eliminates command-injection risk.
+        const opener = process.platform === "darwin" ? "open"
+            : process.platform === "win32" ? "explorer.exe"
+                : "xdg-open";
+        const child = spawn(opener, [url], { stdio: "ignore", detached: true });
+        child.on("error", () => { });
+        child.unref();
     });
 }

package/dist/cli/server/start.js

@@ -24,10 +24,33 @@ export function createServerStartCommand() {
             const isBun = typeof globalThis.Bun !== "undefined";
             const cmd = isBun ? process.execPath : process.execPath;
             const args = isBun ? ["server", "start"] : [process.argv[1], "server", "start"];
+            // Only forward the env vars the daemon actually needs.
+            // Each var is read explicitly (no Object.keys / dynamic indexing into
+            // process.env) so the daemon can't inherit unrelated parent-process
+            // secrets such as AWS_*, GITHUB_TOKEN, OPENAI_API_KEY, etc.
+            const childEnv = {
+                PATH: process.env.PATH ?? "",
+                HOME: process.env.HOME ?? process.env.USERPROFILE ?? "",
+                PORT: String(port),
+                COORDINATOR_DATA_DIR: dataDir,
+            };
+            const fwd = (key, value) => {
+                if (value !== undefined)
+                    childEnv[key] = value;
+            };
+            fwd("NODE_ENV", process.env.NODE_ENV);
+            fwd("LOG_LEVEL", process.env.LOG_LEVEL);
+            fwd("COORDINATOR_AUTH_ENABLED", process.env.COORDINATOR_AUTH_ENABLED);
+            fwd("COORDINATOR_JWT_SECRET", process.env.COORDINATOR_JWT_SECRET);
+            fwd("COORDINATOR_JWT_EXPIRY", process.env.COORDINATOR_JWT_EXPIRY);
+            fwd("COORDINATOR_REGISTRATION_SECRET", process.env.COORDINATOR_REGISTRATION_SECRET);
+            fwd("COORDINATOR_ADMIN_SECRET", process.env.COORDINATOR_ADMIN_SECRET);
+            fwd("COORDINATOR_MQTT_TCP_PORT", process.env.COORDINATOR_MQTT_TCP_PORT);
+            fwd("COORDINATOR_MQTT_WS_PATH", process.env.COORDINATOR_MQTT_WS_PATH);
             const child = spawn(cmd, args, {
                 detached: true,
                 stdio: ["ignore", logFd, logFd],
-                env: { ...process.env, PORT: String(port), COORDINATOR_DATA_DIR: dataDir },
+                env: childEnv,
             });
             // Write PID file
             writeFileSync(join(configDir, "server.pid"), String(child.pid));

package/dist/cli/server/status.js

@@ -1,12 +1,22 @@
 import { Command } from "commander";
 import { readFileSync, existsSync } from "fs";
 import { join } from "path";
-import { execSync } from "child_process";
 import { getConfigDir, loadConfig } from "../config.js";
+async function fetchJson(url, init) {
+    try {
+        const response = await fetch(url, { ...init, signal: AbortSignal.timeout(3000) });
+        if (!response.ok)
+            return null;
+        return (await response.json());
+    }
+    catch {
+        return null;
+    }
+}
 export function createServerStatusCommand() {
     return new Command("status")
         .description("Show coordinator status")
-        .action(() => {
+        .action(async () => {
         const configDir = getConfigDir();
         const pidPath = join(configDir, "server.pid");
         const config = loadConfig();
@@ -26,28 +36,11 @@ export function createServerStatusCommand() {
             console.log("Coordinator: stopped (stale PID file)");
             return;
         }
-        // Health check
-        let health = {};
-        try {
-            const raw = execSync(`curl -s --max-time 3 http://localhost:${port}/health`, {
-                encoding: "utf-8",
-                stdio: ["pipe", "pipe", "pipe"],
-            });
-            health = JSON.parse(raw);
-        }
-        catch { }
-        if (health.status === "ok") {
-            let status = {};
-            try {
-                const raw = execSync(`curl -s --max-time 3 -X POST http://localhost:${port}/api/status`, {
-                    encoding: "utf-8",
-                    stdio: ["pipe", "pipe", "pipe"],
-                });
-                status = JSON.parse(raw);
-            }
-            catch { }
+        const health = await fetchJson(`http://localhost:${port}/health`);
+        if (health?.status === "ok") {
+            const status = await fetchJson(`http://localhost:${port}/api/status`, { method: "POST" });
             console.log(`Coordinator: running (PID ${pid}, port ${port})`);
-            if (status.online !== undefined) {
+            if (status?.online !== undefined) {
                 console.log(`Agents:      ${status.online} online`);
                 console.log(`Threads:     ${status.open_threads} open`);
             }

package/dist/src/agent-activity.js

@@ -59,12 +59,12 @@ export class AgentActivityTracker {
     // ── Private ──
     upsert(agentId, status, file, thread) {
         const db = getDb();
-        db.prepare(`INSERT INTO agent_activity_status (agent_id, activity_status, current_file, current_thread, last_activity_at)
-       VALUES (?, ?, ?, ?, CURRENT_TIMESTAMP)
-       ON CONFLICT(agent_id) DO UPDATE SET
-         activity_status = excluded.activity_status,
-         current_file = excluded.current_file,
-         current_thread = excluded.current_thread,
+        db.prepare(`INSERT INTO agent_activity_status (agent_id, activity_status, current_file, current_thread, last_activity_at)
+       VALUES (?, ?, ?, ?, CURRENT_TIMESTAMP)
+       ON CONFLICT(agent_id) DO UPDATE SET
+         activity_status = excluded.activity_status,
+         current_file = excluded.current_file,
+         current_thread = excluded.current_thread,
          last_activity_at = CURRENT_TIMESTAMP`).run(agentId, status, file, thread);
     }
 }

package/dist/src/agent-registry.js

@@ -2,12 +2,12 @@ import { getDb } from "./database.js";
 export class AgentRegistry {
     register(agentId, name, modules) {
         const db = getDb();
-        db.prepare(`INSERT INTO agents (id, name, modules, status, registered_at, last_seen_at)
-       VALUES (?, ?, ?, 'online', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
-       ON CONFLICT(id) DO UPDATE SET
-         name = excluded.name,
-         modules = excluded.modules,
-         status = 'online',
+        db.prepare(`INSERT INTO agents (id, name, modules, status, registered_at, last_seen_at)
+       VALUES (?, ?, ?, 'online', CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+       ON CONFLICT(id) DO UPDATE SET
+         name = excluded.name,
+         modules = excluded.modules,
+         status = 'online',
          last_seen_at = CURRENT_TIMESTAMP`).run(agentId, name, JSON.stringify(modules));
         return this.get(agentId);
     }

package/dist/src/announce-workflow.d.ts

@@ -0,0 +1,52 @@
+import type { Thread } from "./types.js";
+import type { CoordinatorServices } from "./server-setup.js";
+import type { CategorizedImpact } from "./impact-scorer.js";
+import { type PlanQualityResult } from "./plan-quality.js";
+/**
+ * S2 fix: shared `announce_work` orchestration.
+ *
+ * The MCP tool handler (`server-setup.ts`) and the REST endpoint
+ * (`serve-http.ts`) historically duplicated ~95 lines of code that
+ * scored impact, overrode respondents, auto-resolved when alone,
+ * and emitted impact/introspection/plan-quality SSE events.
+ *
+ * This module extracts that common orchestration. Both transports
+ * call `runCommonAnnounceFlow()` after creating the thread; each
+ * transport then adds its own pre-step (MCP: conflict detection)
+ * and post-step (MCP: MQTT publish + context gathering, REST: JSON
+ * response) so existing SSE/response contracts are preserved.
+ *
+ * Why not unify the response/SSE shapes too? The MCP and REST
+ * `thread_opened` event payloads have DIFFERENT field sets today
+ * (e.g. MCP uses `initiator`, REST uses `agent_id` + `agent_name`).
+ * essaim (and other consumers) may depend on those exact shapes.
+ * Behavioral unification is a separate, riskier change deferred to
+ * a later major.
+ */
+export interface CommonFlowResult {
+    /** The same thread you passed in, refreshed after the override+auto-resolve. */
+    updated: Thread;
+    /** Impact scoring across all online agents. */
+    categorized: CategorizedImpact;
+    /** Concerned agent IDs (== updated.expected_respondents). */
+    respondents: string[];
+    /** Plan quality assessment (callers may emit downgrade event). */
+    planQuality: PlanQualityResult;
+}
+export interface CommonFlowParams {
+    agent_id: string;
+    subject: string;
+    plan?: string;
+    target_modules: string[];
+    target_files: string[];
+    depends_on_files?: string[];
+    exports_affected?: string[];
+    keep_open?: boolean;
+}
+/**
+ * Run the common post-`announceWork` orchestration. Mutates the thread row
+ * (overrides `expected_respondents`, may transition to `resolved`) and emits
+ * SSE events for impact scoring + introspection. Pure side-effects on the
+ * services + DB; returns metadata callers use to build their own responses.
+ */
+export declare function runCommonAnnounceFlow(services: CoordinatorServices, threadId: string, params: CommonFlowParams): CommonFlowResult;

package/dist/src/announce-workflow.js

@@ -0,0 +1,91 @@
+import { getDb } from "./database.js";
+import { assessPlanQuality } from "./plan-quality.js";
+/**
+ * Run the common post-`announceWork` orchestration. Mutates the thread row
+ * (overrides `expected_respondents`, may transition to `resolved`) and emits
+ * SSE events for impact scoring + introspection. Pure side-effects on the
+ * services + DB; returns metadata callers use to build their own responses.
+ */
+export function runCommonAnnounceFlow(services, threadId, params) {
+    const { registry, consultation, impactScorer, introspection, sseEmitter } = services;
+    // 1. Score impact: categorize all online agents into concerned / gray_zone / pass.
+    const categorized = impactScorer.categorize({
+        agent_id: params.agent_id,
+        target_modules: params.target_modules,
+        target_files: params.target_files,
+        depends_on_files: params.depends_on_files,
+        exports_affected: params.exports_affected,
+    });
+    // 2. Override expected_respondents on the thread with the scored set.
+    // Auto-resolve only when truly alone — if peers are online but not concerned
+    // (e.g., they haven't announced yet), keep the thread open so a subsequent
+    // announce can match via Layer 0. Thread will timeout naturally if no one joins.
+    const db = getDb();
+    const concernedIds = categorized.concerned.map((s) => s.agent_id);
+    db.prepare("UPDATE threads SET expected_respondents = ? WHERE id = ?")
+        .run(JSON.stringify(concernedIds), threadId);
+    const otherOnlineCount = registry.listOnline().filter((a) => a.id !== params.agent_id).length;
+    const shouldAutoResolve = concernedIds.length === 0 && otherOnlineCount === 0;
+    const currentThread = consultation.getThread(threadId);
+    if (shouldAutoResolve && currentThread.status === "open" && !params.keep_open) {
+        db.prepare("UPDATE threads SET status = 'resolved', resolved_at = ? WHERE id = ?")
+            .run(new Date().toISOString(), threadId);
+        consultation.emitResolution(threadId, "auto_resolved");
+    }
+    // 3. Emit impact_scored SSE events for every scored agent.
+    for (const s of [...categorized.concerned, ...categorized.gray_zone, ...categorized.pass]) {
+        sseEmitter.emit("impact_scored", {
+            thread_id: threadId,
+            agent_id: s.agent_id,
+            agent_name: s.agent_name,
+            score: s.score,
+            reasons: s.reasons,
+            category: scoredCategory(s),
+        });
+    }
+    // 4. Create introspection records and emit introspection_requested for gray_zone agents.
+    for (const s of categorized.gray_zone) {
+        introspection.create({ thread_id: threadId, agent_id: s.agent_id, score: s.score, reasons: s.reasons });
+        sseEmitter.emit("introspection_requested", {
+            thread_id: threadId,
+            agent_id: s.agent_id,
+            agent_name: s.agent_name,
+            score: s.score,
+            reasons: s.reasons,
+        });
+    }
+    // 5. Plan quality downgrade event — both transports emit this when a plan
+    // was provided but quality was insufficient. Callers can re-emit if their
+    // payload shape differs (MCP vs REST agent_name source).
+    const planQuality = assessPlanQuality(params.plan);
+    if (params.plan && planQuality.mode === "discovery") {
+        sseEmitter.emit("impact_scored", {
+            thread_id: threadId,
+            agent_id: params.agent_id,
+            agent_name: registry.get(params.agent_id)?.name || params.agent_id,
+            score: planQuality.score,
+            reasons: [planDowngradeReason(planQuality)],
+            category: "plan_quality",
+        });
+    }
+    const updated = consultation.getThread(threadId);
+    const respondents = JSON.parse(updated.expected_respondents || "[]");
+    return { updated, categorized, respondents, planQuality };
+}
+function scoredCategory(s) {
+    if (s.score >= 90)
+        return "concerned";
+    if (s.score >= 30)
+        return "gray_zone";
+    return "pass";
+}
+function planDowngradeReason(pq) {
+    const flags = [];
+    if (!pq.checks.mentions_files)
+        flags.push("no files");
+    if (!pq.checks.concrete_approach)
+        flags.push("vague approach");
+    if (!pq.checks.sufficient_detail)
+        flags.push("too short");
+    return `plan downgraded: score ${pq.score}/3 — ${flags.join(" ")}`.trim();
+}

package/dist/src/consultation.d.ts

@@ -13,8 +13,22 @@ export interface ResolutionEvent {
 export declare class Consultation {
     private onResolveCallback;
     private log;
+    private timeoutSweeperHandle;
     constructor(logger?: Logger);
     onResolve(callback: (event: ResolutionEvent) => void): void;
+    /**
+     * B2 fix: replace the side-effect-on-read timeout check with an explicit
+     * background sweeper. Each tick atomically claims and resolves any thread
+     * past its deadline, then emits resolution events outside the transaction.
+     *
+     * Default tick interval: 30 seconds. Tests can pass a shorter interval to
+     * exercise the sweeper, or call checkTimeouts() explicitly.
+     *
+     * Safe to call multiple times — second call is a no-op until the previous
+     * sweeper is stopped.
+     */
+    startTimeoutSweeper(intervalMs?: number): void;
+    stopTimeoutSweeper(): void;
     emitResolution(threadId: string, type: ResolutionType, approvedBy?: string, approvedByName?: string): void;
     announceWork(params: {
         agent_id: string;

package/dist/src/consultation.js

@@ -4,12 +4,45 @@ import { silentLogger } from "./logger.js";
 export class Consultation {
     onResolveCallback = null;
     log;
+    timeoutSweeperHandle = null;
     constructor(logger) {
         this.log = logger || silentLogger;
     }
     onResolve(callback) {
         this.onResolveCallback = callback;
     }
+    /**
+     * B2 fix: replace the side-effect-on-read timeout check with an explicit
+     * background sweeper. Each tick atomically claims and resolves any thread
+     * past its deadline, then emits resolution events outside the transaction.
+     *
+     * Default tick interval: 30 seconds. Tests can pass a shorter interval to
+     * exercise the sweeper, or call checkTimeouts() explicitly.
+     *
+     * Safe to call multiple times — second call is a no-op until the previous
+     * sweeper is stopped.
+     */
+    startTimeoutSweeper(intervalMs = 30000) {
+        if (this.timeoutSweeperHandle)
+            return;
+        this.timeoutSweeperHandle = setInterval(() => {
+            try {
+                this.checkTimeouts();
+            }
+            catch (err) {
+                this.log.warn({ err }, "Timeout sweeper iteration failed");
+            }
+        }, intervalMs);
+        // Don't keep the event loop alive just for the sweeper.
+        if (typeof this.timeoutSweeperHandle.unref === "function")
+            this.timeoutSweeperHandle.unref();
+    }
+    stopTimeoutSweeper() {
+        if (this.timeoutSweeperHandle) {
+            clearInterval(this.timeoutSweeperHandle);
+            this.timeoutSweeperHandle = null;
+        }
+    }
     emitResolution(threadId, type, approvedBy, approvedByName) {
         const db = getDb();
         const thread = this.getThread(threadId);
@@ -39,23 +72,31 @@ export class Consultation {
     announceWork(params) {
         const db = getDb();
         const id = randomUUID();
-        // Find expected respondents: online agents (not initiator) whose modules overlap
-        const onlineAgents = db
-            .prepare("SELECT id, modules FROM agents WHERE status = 'online' AND id != ?")
-            .all(params.agent_id);
-        const respondents = onlineAgents.filter((agent) => {
-            const agentModules = JSON.parse(agent.modules);
-            return params.target_modules.some((tm) => agentModules.some((am) => am === tm || am.startsWith(tm + "/") || tm.startsWith(am + "/")));
+        // B1 fix: SELECT respondents + INSERT thread must be atomic w.r.t. agent
+        // registry mutations (registerAgent / setOffline). Without a transaction,
+        // a race between announce and a concurrent setOffline produces a thread
+        // whose expected_respondents contains an agent that just went away — the
+        // thread then stays open forever waiting for an absent voter.
+        const tx = db.transaction(() => {
+            const onlineAgents = db
+                .prepare("SELECT id, modules FROM agents WHERE status = 'online' AND id != ?")
+                .all(params.agent_id);
+            const respondents = onlineAgents.filter((agent) => {
+                const agentModules = JSON.parse(agent.modules);
+                return params.target_modules.some((tm) => agentModules.some((am) => am === tm || am.startsWith(tm + "/") || tm.startsWith(am + "/")));
+            });
+            const respondentIds = respondents.map((r) => r.id);
+            // Directed dispatch skips module-based auto-resolve: if the thread is
+            // explicitly aimed at an agent, we keep it open for them regardless of
+            // what the module scorer finds.
+            const assignedTo = params.assigned_to ?? null;
+            const keepOpen = params.keep_open || assignedTo !== null;
+            const autoResolve = respondentIds.length === 0 && !keepOpen;
+            db.prepare(`INSERT INTO threads (id, initiator_id, subject, plan, target_modules, target_files, status, expected_respondents, resolved_at, depends_on_files, exports_affected, timeout_seconds, assigned_to)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, params.agent_id, params.subject, params.plan || null, JSON.stringify(params.target_modules), JSON.stringify(params.target_files), autoResolve ? "resolved" : "open", JSON.stringify(respondentIds), autoResolve ? new Date().toISOString() : null, JSON.stringify(params.depends_on_files || []), JSON.stringify(params.exports_affected || []), keepOpen ? 0 : 600, assignedTo);
+            return { autoResolve, respondentIds, assignedTo };
         });
-        const respondentIds = respondents.map((r) => r.id);
-        // Directed dispatch skips module-based auto-resolve: if the thread is
-        // explicitly aimed at an agent, we keep it open for them regardless of
-        // what the module scorer finds.
-        const assignedTo = params.assigned_to ?? null;
-        const keepOpen = params.keep_open || assignedTo !== null;
-        const autoResolve = respondentIds.length === 0 && !keepOpen;
-        db.prepare(`INSERT INTO threads (id, initiator_id, subject, plan, target_modules, target_files, status, expected_respondents, resolved_at, depends_on_files, exports_affected, timeout_seconds, assigned_to)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, params.agent_id, params.subject, params.plan || null, JSON.stringify(params.target_modules), JSON.stringify(params.target_files), autoResolve ? "resolved" : "open", JSON.stringify(respondentIds), autoResolve ? new Date().toISOString() : null, JSON.stringify(params.depends_on_files || []), JSON.stringify(params.exports_affected || []), keepOpen ? 0 : 600, assignedTo);
+        const { autoResolve, respondentIds, assignedTo } = tx();
         this.log.info({
             thread_id: id,
             agent_id: params.agent_id,
@@ -81,7 +122,7 @@ export class Consultation {
         const id = randomUUID();
         // Simple token estimate: ~4 chars per token for English/French
         const tokenEstimate = Math.ceil(params.content.length / 4);
-        db.prepare(`INSERT INTO thread_messages (id, thread_id, agent_id, agent_name, type, content, context_snapshot, in_reply_to, round, token_estimate)
+        db.prepare(`INSERT INTO thread_messages (id, thread_id, agent_id, agent_name, type, content, context_snapshot, in_reply_to, round, token_estimate)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, params.thread_id, params.agent_id, params.agent_name || null, params.type, params.content, params.context_snapshot || null, params.in_reply_to || null, thread.round, tokenEstimate);
         this.log.debug({
             thread_id: params.thread_id,
@@ -109,12 +150,23 @@ export class Consultation {
             throw new Error(`Thread ${threadId} not found`);
         if (thread.status !== "resolving")
             throw new Error(`Thread is ${thread.status}, not resolving`);
-        // Post approve message
-        this.postResolutionMessage(threadId, agentId, "approve", "Approved");
+        // B1 fix: post + check + transition must be atomic, else two concurrent
+        // approvals each see "all approved" and fire emitResolution twice. Using
+        // a transaction + UPDATE ... WHERE status='resolving' (CAS) ensures only
+        // the first transaction wins the consensus race; the loser's UPDATE
+        // affects 0 rows and emit is suppressed.
+        const tx = db.transaction(() => {
+            this.postResolutionMessage(threadId, agentId, "approve", "Approved");
+            if (!this.allRespondentsApproved(threadId))
+                return false;
+            const res = db
+                .prepare("UPDATE threads SET status = 'resolved', resolved_at = ? WHERE id = ? AND status = 'resolving'")
+                .run(new Date().toISOString(), threadId);
+            return res.changes > 0;
+        });
+        const wonRace = tx();
         this.log.debug({ thread_id: threadId, agent_id: agentId }, "Resolution approved");
-        // Check if all expected respondents have approved
-        if (this.allRespondentsApproved(threadId)) {
-            db.prepare("UPDATE threads SET status = 'resolved', resolved_at = ? WHERE id = ?").run(new Date().toISOString(), threadId);
+        if (wonRace) {
             this.emitResolution(threadId, "consensus", agentId, agentName || agentId);
         }
     }
@@ -194,30 +246,43 @@ export class Consultation {
     }
     checkTimeouts() {
         const db = getDb();
-        // Get threads that will be timed out (before updating them)
-        const timedOut = db.prepare(`
-      SELECT id FROM threads
-      WHERE status IN ('open', 'resolving')
-      AND timeout_seconds > 0
-      AND datetime(created_at, '+' || (timeout_seconds * round) || ' seconds') < CURRENT_TIMESTAMP
-    `).all();
+        // B2 fix: SELECT-then-UPDATE wrapped in a transaction so two concurrent
+        // sweepers can't both claim the same thread. The UPDATE returns
+        // db.changes (rows affected) — we use the SELECT only to know which
+        // thread IDs to emit for. The transaction makes both observe the same
+        // snapshot.
+        const tx = db.transaction(() => {
+            const timedOut = db.prepare(`
+        SELECT id FROM threads
+        WHERE status IN ('open', 'resolving')
+        AND timeout_seconds > 0
+        AND datetime(created_at, '+' || (timeout_seconds * round) || ' seconds') < CURRENT_TIMESTAMP
+      `).all();
+            if (timedOut.length === 0)
+                return [];
+            db.prepare(`
+        UPDATE threads SET status = 'resolved',
+          resolution_summary = 'Résolu par timeout — pas de réponse dans le délai',
+          resolved_at = CURRENT_TIMESTAMP
+        WHERE status IN ('open', 'resolving')
+        AND timeout_seconds > 0
+        AND datetime(created_at, '+' || (timeout_seconds * round) || ' seconds') < CURRENT_TIMESTAMP
+      `).run();
+            return timedOut;
+        });
+        const timedOut = tx();
         if (timedOut.length === 0)
             return;
-        db.prepare(`
-      UPDATE threads SET status = 'resolved',
-        resolution_summary = 'Résolu par timeout — pas de réponse dans le délai',
-        resolved_at = CURRENT_TIMESTAMP
-      WHERE status IN ('open', 'resolving')
-      AND timeout_seconds > 0
-      AND datetime(created_at, '+' || (timeout_seconds * round) || ' seconds') < CURRENT_TIMESTAMP
-    `).run();
         this.log.info({ count: timedOut.length, thread_ids: timedOut.map(t => t.id) }, "Threads timed out");
+        // Emit OUTSIDE the transaction so listeners can re-enter the DB safely.
         for (const t of timedOut) {
             this.emitResolution(t.id, "timeout");
         }
     }
     getThread(threadId) {
-        this.checkTimeouts();
+        // B2 fix: timeout sweeping moved to startTimeoutSweeper() background timer.
+        // Reads no longer mutate state. Tests that need synchronous timeout
+        // resolution should call checkTimeouts() explicitly.
         const db = getDb();
         return (db.prepare("SELECT * FROM threads WHERE id = ?").get(threadId) || null);
     }
@@ -232,7 +297,7 @@ export class Consultation {
         return { thread, messages };
     }
     listThreads(filters) {
-        this.checkTimeouts();
+        // B2 fix: removed checkTimeouts() side-effect; sweeper handles it.
         const db = getDb();
         let sql = "SELECT * FROM threads WHERE 1=1";
         const params = [];
@@ -260,9 +325,9 @@ export class Consultation {
     }
     getThreadUpdates(agentId, since) {
         const db = getDb();
-        let sql = `SELECT tm.* FROM thread_messages tm
-               JOIN threads t ON tm.thread_id = t.id
-               WHERE t.status IN ('open', 'resolving')
+        let sql = `SELECT tm.* FROM thread_messages tm
+               JOIN threads t ON tm.thread_id = t.id
+               WHERE t.status IN ('open', 'resolving')
                AND tm.agent_id != ?`;
         const params = [agentId];
         if (since) {
@@ -284,7 +349,7 @@ export class Consultation {
     logActionSummary(params) {
         const db = getDb();
         const id = randomUUID();
-        db.prepare(`INSERT INTO action_summaries (id, session_id, agent_id, file_path, summary)
+        db.prepare(`INSERT INTO action_summaries (id, session_id, agent_id, file_path, summary)
        VALUES (?, ?, ?, ?, ?)`).run(id, params.session_id, params.agent_id, params.file_path || null, params.summary);
         return db.prepare("SELECT * FROM action_summaries WHERE id = ?").get(id);
     }
@@ -310,7 +375,7 @@ export class Consultation {
         const db = getDb();
         const thread = this.getThread(threadId);
         const id = randomUUID();
-        db.prepare(`INSERT INTO thread_messages (id, thread_id, agent_id, type, content, round)
+        db.prepare(`INSERT INTO thread_messages (id, thread_id, agent_id, type, content, round)
        VALUES (?, ?, ?, ?, ?, ?)`).run(id, threadId, agentId, type, content, thread.round);
     }
     allRespondentsApproved(threadId) {
@@ -323,7 +388,7 @@ export class Consultation {
         // increments the round, and prior-round approvals must be re-collected
         // for the new proposal.
         const approvals = db
-            .prepare(`SELECT DISTINCT agent_id FROM thread_messages
+            .prepare(`SELECT DISTINCT agent_id FROM thread_messages
          WHERE thread_id = ? AND type = 'approve' AND round = ?`)
             .all(threadId, thread.round);
         const approvedIds = new Set(approvals.map((a) => a.agent_id));