mcp-coordinator 0.1.0

package/dist/src/conflict-detector.js

@@ -0,0 +1,114 @@
+import { silentLogger } from "./logger.js";
+export class ConflictDetector {
+    consultation;
+    depMap;
+    fileTracker;
+    log;
+    constructor(consultation, depMap, fileTracker, logger) {
+        this.consultation = consultation;
+        this.depMap = depMap;
+        this.fileTracker = fileTracker;
+        this.log = logger || silentLogger;
+    }
+    detect(params) {
+        const conflicts = [];
+        // Include open, resolving, and recently resolved (auto-quorum) threads — exclude only cancelled
+        const allThreads = this.consultation.listThreads({});
+        const activeThreads = allThreads.filter((t) => t.status !== "cancelled");
+        for (const thread of activeThreads) {
+            if (thread.initiator_id === params.agent_id)
+                continue;
+            const threadModules = JSON.parse(thread.target_modules);
+            const threadFiles = JSON.parse(thread.target_files);
+            // 1. Module overlap
+            const moduleOverlap = params.target_modules.filter((m) => threadModules.includes(m));
+            if (moduleOverlap.length > 0) {
+                conflicts.push({
+                    type: "module_overlap",
+                    severity: "warning",
+                    agent_id: thread.initiator_id,
+                    agent_name: thread.subject,
+                    description: `Module overlap on: ${moduleOverlap.join(", ")}`,
+                    details: `Thread "${thread.subject}" (${thread.initiator_id}) targets same modules`,
+                });
+            }
+            // 2. File overlap
+            const fileOverlap = params.target_files.filter((f) => threadFiles.includes(f));
+            if (fileOverlap.length > 0) {
+                conflicts.push({
+                    type: "file_overlap",
+                    severity: "warning",
+                    agent_id: thread.initiator_id,
+                    agent_name: thread.subject,
+                    description: `File overlap on: ${fileOverlap.join(", ")}`,
+                    details: `Thread "${thread.subject}" (${thread.initiator_id}) targets same files`,
+                });
+            }
+            // 3. Dependency chain
+            for (const targetModule of params.target_modules) {
+                const info = this.depMap.getModuleInfo(targetModule);
+                if (!info)
+                    continue;
+                for (const dep of info.depends_on) {
+                    if (threadModules.includes(dep)) {
+                        conflicts.push({
+                            type: "dependency_chain",
+                            severity: "info",
+                            agent_id: thread.initiator_id,
+                            agent_name: thread.subject,
+                            description: `${targetModule} depends on ${dep} which is being modified`,
+                            details: `Thread "${thread.subject}" modifies ${dep}, a dependency of ${targetModule}`,
+                        });
+                    }
+                }
+                // Reverse: someone depends on what we're modifying
+                const radius = this.depMap.getBlastRadius(targetModule);
+                this.log.debug({
+                    module_id: targetModule,
+                    direct_dependents: radius.direct_dependents,
+                    indirect_dependents: radius.indirect_dependents,
+                }, "Blast radius calculated");
+                for (const dependent of [...radius.direct_dependents, ...radius.indirect_dependents]) {
+                    if (threadModules.includes(dependent)) {
+                        conflicts.push({
+                            type: "dependency_chain",
+                            severity: "info",
+                            agent_id: thread.initiator_id,
+                            agent_name: thread.subject,
+                            description: `${dependent} depends on ${targetModule} which you are modifying`,
+                            details: `Thread "${thread.subject}" works on ${dependent}, which depends on ${targetModule}`,
+                        });
+                    }
+                }
+            }
+        }
+        // 4. Hot file overlap (from actual file activity, not just declared files)
+        for (const targetFile of params.target_files) {
+            const activity = this.fileTracker.checkFileConflict(targetFile, params.agent_id, 60);
+            if (activity.conflict) {
+                for (const otherAgent of activity.agents) {
+                    // Avoid duplicating with file_overlap already detected
+                    if (!conflicts.some(c => c.agent_id === otherAgent && c.type === "file_overlap")) {
+                        conflicts.push({
+                            type: "file_overlap",
+                            severity: "warning",
+                            agent_id: otherAgent,
+                            agent_name: otherAgent,
+                            description: `Hot file: ${targetFile} recently edited by ${otherAgent}`,
+                            details: `File activity shows ${targetFile} was recently modified by ${otherAgent}`,
+                        });
+                    }
+                }
+            }
+        }
+        if (conflicts.length > 0) {
+            this.log.warn({
+                agent_id: params.agent_id,
+                conflict_count: conflicts.length,
+                types: [...new Set(conflicts.map(c => c.type))],
+                modules: params.target_modules,
+            }, "Conflicts detected");
+        }
+        return conflicts;
+    }
+}

package/dist/src/consultation.d.ts

@@ -0,0 +1,75 @@
+import { type Logger } from "./logger.js";
+import type { Thread, ThreadMessage, ActionSummary, MessageType, ResolutionType } from "./types.js";
+export interface ResolutionEvent {
+    thread_id: string;
+    resolution_type: ResolutionType;
+    resolution_summary: string | null;
+    created_at: string;
+    resolved_at: string;
+    approved_by?: string;
+    approved_by_name?: string;
+    had_messages: boolean;
+}
+export declare class Consultation {
+    private onResolveCallback;
+    private log;
+    constructor(logger?: Logger);
+    onResolve(callback: (event: ResolutionEvent) => void): void;
+    emitResolution(threadId: string, type: ResolutionType, approvedBy?: string, approvedByName?: string): void;
+    announceWork(params: {
+        agent_id: string;
+        subject: string;
+        plan?: string;
+        target_modules: string[];
+        target_files: string[];
+        depends_on_files?: string[];
+        exports_affected?: string[];
+        keep_open?: boolean;
+        assigned_to?: string | null;
+    }): Thread;
+    postToThread(params: {
+        thread_id: string;
+        agent_id: string;
+        agent_name?: string;
+        type: MessageType;
+        content: string;
+        context_snapshot?: string;
+        in_reply_to?: string;
+    }): ThreadMessage;
+    proposeResolution(threadId: string, agentId: string, summary: string): void;
+    approveResolution(threadId: string, agentId: string, agentName?: string): void;
+    contestResolution(threadId: string, agentId: string, reason: string): void;
+    cancelThread(threadId: string, agentId: string, reason?: string): void;
+    closeThread(threadId: string, agentId: string, summary: string): void;
+    handleAgentDeparture(agentId: string): void;
+    checkTimeouts(): void;
+    getThread(threadId: string): Thread | null;
+    getThreadWithMessages(threadId: string): {
+        thread: Thread;
+        messages: ThreadMessage[];
+    } | null;
+    listThreads(filters: {
+        status?: string;
+        agent_id?: string;
+        module?: string;
+        /**
+         * When set, only return threads that are claimable by this agent:
+         *   assigned_to IS NULL  (open pool — anyone can take it)
+         *   OR assigned_to = agent_id  (directed to me)
+         * Workers use this to filter out dispatches for other agents without
+         * parsing the thread list themselves.
+         */
+        assigned_to_me?: string;
+    }): Thread[];
+    getThreadUpdates(agentId: string, since?: string): ThreadMessage[];
+    logActionSummary(params: {
+        session_id: string;
+        agent_id: string;
+        file_path?: string;
+        summary: string;
+    }): ActionSummary;
+    getActionSummaries(agentId: string, since?: string): ActionSummary[];
+    getActionSummariesBySession(sessionId: string): ActionSummary[];
+    private postResolutionMessage;
+    private allRespondentsApproved;
+}

package/dist/src/consultation.js

@@ -0,0 +1,332 @@
+import { randomUUID } from "crypto";
+import { getDb } from "./database.js";
+import { silentLogger } from "./logger.js";
+export class Consultation {
+    onResolveCallback = null;
+    log;
+    constructor(logger) {
+        this.log = logger || silentLogger;
+    }
+    onResolve(callback) {
+        this.onResolveCallback = callback;
+    }
+    emitResolution(threadId, type, approvedBy, approvedByName) {
+        const db = getDb();
+        const thread = this.getThread(threadId);
+        if (!thread)
+            return;
+        const messageCount = db.prepare("SELECT COUNT(*) as count FROM thread_messages WHERE thread_id = ?").get(threadId).count;
+        const durationMs = thread ? Date.now() - new Date(thread.created_at).getTime() : undefined;
+        this.log.info({
+            thread_id: threadId,
+            resolution_type: type,
+            approved_by: approvedBy,
+            duration_ms: durationMs,
+        }, "Thread resolved");
+        if (this.onResolveCallback) {
+            this.onResolveCallback({
+                thread_id: threadId,
+                resolution_type: type,
+                resolution_summary: thread.resolution_summary,
+                created_at: thread.created_at,
+                resolved_at: thread.resolved_at || new Date().toISOString(),
+                approved_by: approvedBy,
+                approved_by_name: approvedByName,
+                had_messages: messageCount > 0,
+            });
+        }
+    }
+    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 + "/")));
+        });
+        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);
+        this.log.info({
+            thread_id: id,
+            agent_id: params.agent_id,
+            subject: params.subject,
+            target_modules: params.target_modules,
+            auto_resolve: autoResolve,
+            respondent_count: respondentIds.length,
+            assigned_to: assignedTo,
+        }, "Thread opened");
+        return this.getThread(id);
+    }
+    postToThread(params) {
+        const db = getDb();
+        const thread = this.getThread(params.thread_id);
+        if (!thread)
+            throw new Error(`Thread ${params.thread_id} not found`);
+        // Cancelled threads are explicit aborts — reject posts.
+        // Resolved threads accept late posts (audit/enrichment) because the review
+        // phase races with auto-resolve: an ENRICHIT computed against an open
+        // thread may arrive milliseconds after the thread transitioned to resolved.
+        if (thread.status === "cancelled")
+            throw new Error(`Thread ${params.thread_id} is cancelled`);
+        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)
+       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,
+            agent_id: params.agent_id,
+            type: params.type,
+            content_length: params.content.length,
+        }, "Message posted to thread");
+        return db.prepare("SELECT * FROM thread_messages WHERE id = ?").get(id);
+    }
+    proposeResolution(threadId, agentId, summary) {
+        const db = getDb();
+        const thread = this.getThread(threadId);
+        if (!thread)
+            throw new Error(`Thread ${threadId} not found`);
+        if (thread.initiator_id !== agentId && thread.claimed_by !== agentId)
+            throw new Error("Only the initiator or the claimant can propose a resolution");
+        db.prepare("UPDATE threads SET status = 'resolving', resolution_summary = ? WHERE id = ?").run(summary, threadId);
+        // Post resolution message
+        this.postResolutionMessage(threadId, agentId, "resolution", summary);
+    }
+    approveResolution(threadId, agentId, agentName) {
+        const db = getDb();
+        const thread = this.getThread(threadId);
+        if (!thread)
+            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");
+        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);
+            this.emitResolution(threadId, "consensus", agentId, agentName || agentId);
+        }
+    }
+    contestResolution(threadId, agentId, reason) {
+        const db = getDb();
+        const thread = this.getThread(threadId);
+        if (!thread)
+            throw new Error(`Thread ${threadId} not found`);
+        if (thread.status !== "resolving")
+            throw new Error(`Thread is ${thread.status}, not resolving`);
+        // Post contest message
+        this.postResolutionMessage(threadId, agentId, "contest", reason);
+        this.log.debug({ thread_id: threadId, agent_id: agentId, reason }, "Resolution contested");
+        // Return to open with next round
+        const nextRound = thread.round + 1;
+        if (nextRound > thread.max_rounds) {
+            // Max rounds reached — force resolve
+            db.prepare("UPDATE threads SET status = 'resolved', resolved_at = ? WHERE id = ?").run(new Date().toISOString(), threadId);
+            this.emitResolution(threadId, "max_rounds");
+        }
+        else {
+            db.prepare("UPDATE threads SET status = 'open', round = ?, resolution_summary = NULL WHERE id = ?").run(nextRound, threadId);
+        }
+    }
+    cancelThread(threadId, agentId, reason) {
+        const db = getDb();
+        const thread = this.getThread(threadId);
+        if (!thread)
+            throw new Error(`Thread ${threadId} not found`);
+        if (thread.initiator_id !== agentId)
+            throw new Error("Only the initiator can cancel");
+        db.prepare("UPDATE threads SET status = 'cancelled', resolved_at = ? WHERE id = ?").run(new Date().toISOString(), threadId);
+        if (reason) {
+            this.postResolutionMessage(threadId, agentId, "context", `Cancelled: ${reason}`);
+        }
+    }
+    closeThread(threadId, agentId, summary) {
+        const db = getDb();
+        const thread = this.getThread(threadId);
+        if (!thread) {
+            throw new Error(`Thread ${threadId} not found`);
+        }
+        if (thread.initiator_id !== agentId) {
+            throw new Error(`Only the initiator (${thread.initiator_id}) may close thread ${threadId}, not ${agentId}`);
+        }
+        if (thread.status !== "open" && thread.status !== "resolving") {
+            throw new Error(`Cannot close thread ${threadId} in status '${thread.status}'`);
+        }
+        db.prepare("UPDATE threads SET status = 'resolved', resolution_summary = ?, resolved_at = ? WHERE id = ?").run(summary, new Date().toISOString(), threadId);
+        this.emitResolution(threadId, "closed");
+    }
+    handleAgentDeparture(agentId) {
+        const db = getDb();
+        // Unclaim any tasks claimed by the departing agent
+        db.prepare("UPDATE threads SET claimed_by = NULL, claimed_at = NULL WHERE claimed_by = ? AND status = 'open'")
+            .run(agentId);
+        // Remove departed agent from expected_respondents of all open/resolving threads
+        const threads = db
+            .prepare("SELECT id, expected_respondents FROM threads WHERE status IN ('open', 'resolving')")
+            .all();
+        for (const thread of threads) {
+            const respondents = JSON.parse(thread.expected_respondents || "[]");
+            const updated = respondents.filter((r) => r !== agentId);
+            db.prepare("UPDATE threads SET expected_respondents = ? WHERE id = ?").run(JSON.stringify(updated), thread.id);
+            // If resolving and all remaining approved, resolve
+            const t = this.getThread(thread.id);
+            if (t.status === "resolving" && this.allRespondentsApproved(thread.id)) {
+                db.prepare("UPDATE threads SET status = 'resolved', resolved_at = ? WHERE id = ?").run(new Date().toISOString(), thread.id);
+                this.emitResolution(thread.id, "agent_departure");
+            }
+            // If open and no respondents left, auto-resolve
+            if (t.status === "open" && updated.length === 0) {
+                db.prepare("UPDATE threads SET status = 'resolved', resolved_at = ? WHERE id = ?").run(new Date().toISOString(), thread.id);
+                this.emitResolution(thread.id, "agent_departure");
+            }
+        }
+    }
+    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();
+        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");
+        for (const t of timedOut) {
+            this.emitResolution(t.id, "timeout");
+        }
+    }
+    getThread(threadId) {
+        this.checkTimeouts();
+        const db = getDb();
+        return (db.prepare("SELECT * FROM threads WHERE id = ?").get(threadId) || null);
+    }
+    getThreadWithMessages(threadId) {
+        const thread = this.getThread(threadId);
+        if (!thread)
+            return null;
+        const db = getDb();
+        const messages = db
+            .prepare("SELECT * FROM thread_messages WHERE thread_id = ? ORDER BY created_at")
+            .all(threadId);
+        return { thread, messages };
+    }
+    listThreads(filters) {
+        this.checkTimeouts();
+        const db = getDb();
+        let sql = "SELECT * FROM threads WHERE 1=1";
+        const params = [];
+        if (filters.status) {
+            sql += " AND status = ?";
+            params.push(filters.status);
+        }
+        if (filters.agent_id) {
+            sql += " AND initiator_id = ?";
+            params.push(filters.agent_id);
+        }
+        if (filters.module) {
+            // Exact match against each array element via json_each — LIKE on the
+            // serialized JSON caused false positives where "src/api" matched
+            // "src/api-gateway" too.
+            sql += " AND EXISTS (SELECT 1 FROM json_each(target_modules) WHERE value = ?)";
+            params.push(filters.module);
+        }
+        if (filters.assigned_to_me) {
+            sql += " AND (assigned_to IS NULL OR assigned_to = ?)";
+            params.push(filters.assigned_to_me);
+        }
+        sql += " ORDER BY created_at DESC";
+        return db.prepare(sql).all(...params);
+    }
+    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')
+               AND tm.agent_id != ?`;
+        const params = [agentId];
+        if (since) {
+            sql += " AND tm.created_at >= ?";
+            // Normalize ANY parseable ISO/date string (including timezone offsets
+            // like "+05:00", "-0800", fractional seconds) to SQLite CURRENT_TIMESTAMP
+            // format "YYYY-MM-DD HH:MM:SS" in UTC. The old regex-based normalization
+            // only handled the `.\d+$` suffix, which left "+05:00" in place and
+            // broke the comparison.
+            const date = new Date(since);
+            const normalized = isNaN(date.getTime())
+                ? since
+                : date.toISOString().replace("T", " ").slice(0, 19);
+            params.push(normalized);
+        }
+        sql += " ORDER BY tm.created_at";
+        return db.prepare(sql).all(...params);
+    }
+    logActionSummary(params) {
+        const db = getDb();
+        const id = randomUUID();
+        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);
+    }
+    getActionSummaries(agentId, since) {
+        const db = getDb();
+        let sql = "SELECT * FROM action_summaries WHERE agent_id = ?";
+        const params = [agentId];
+        if (since) {
+            sql += " AND created_at > ?";
+            params.push(since);
+        }
+        sql += " ORDER BY created_at DESC";
+        return db.prepare(sql).all(...params);
+    }
+    getActionSummariesBySession(sessionId) {
+        const db = getDb();
+        return db
+            .prepare("SELECT * FROM action_summaries WHERE session_id = ? ORDER BY created_at")
+            .all(sessionId);
+    }
+    // ── Private helpers ──
+    postResolutionMessage(threadId, agentId, type, content) {
+        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)
+       VALUES (?, ?, ?, ?, ?, ?)`).run(id, threadId, agentId, type, content, thread.round);
+    }
+    allRespondentsApproved(threadId) {
+        const db = getDb();
+        const thread = this.getThread(threadId);
+        const expected = JSON.parse(thread.expected_respondents || "[]");
+        if (expected.length === 0)
+            return true;
+        // Only count approvals from the CURRENT round. A contested resolution
+        // 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
+         WHERE thread_id = ? AND type = 'approve' AND round = ?`)
+            .all(threadId, thread.round);
+        const approvedIds = new Set(approvals.map((a) => a.agent_id));
+        return expected.every((id) => approvedIds.has(id));
+    }
+}

package/dist/src/context-provider.d.ts

@@ -0,0 +1,14 @@
+import type { AgentContext, ConsultationAnnounce } from "./types.js";
+import type { AgentRegistry } from "./agent-registry.js";
+import type { Consultation } from "./consultation.js";
+import type { FileTracker } from "./file-tracker.js";
+export interface ContextProvider {
+    getRelevantContext(agentId: string, query: ConsultationAnnounce): AgentContext;
+}
+export declare class SummaryContextProvider implements ContextProvider {
+    private registry;
+    private consultation;
+    private fileTracker;
+    constructor(registry: AgentRegistry, consultation: Consultation, fileTracker: FileTracker);
+    getRelevantContext(agentId: string, query: ConsultationAnnounce): AgentContext;
+}

package/dist/src/context-provider.js

@@ -0,0 +1,34 @@
+export class SummaryContextProvider {
+    registry;
+    consultation;
+    fileTracker;
+    constructor(registry, consultation, fileTracker) {
+        this.registry = registry;
+        this.consultation = consultation;
+        this.fileTracker = fileTracker;
+    }
+    getRelevantContext(agentId, query) {
+        const agent = this.registry.get(agentId);
+        if (!agent) {
+            return { agent_id: agentId, modules: [], recent_files: [], action_summaries: [] };
+        }
+        const agentModules = JSON.parse(agent.modules);
+        // Filter to only overlapping modules
+        const overlapping = agentModules.filter((am) => query.target_modules.some((tm) => am === tm || am.startsWith(tm + "/") || tm.startsWith(am + "/")));
+        if (overlapping.length === 0) {
+            return { agent_id: agentId, modules: [], recent_files: [], action_summaries: [] };
+        }
+        // Get action summaries for this agent
+        const summaries = this.consultation.getActionSummaries(agentId);
+        // Get recent files from action summaries (agent writes these via MCP tool)
+        const recentFiles = summaries
+            .filter((s) => s.file_path)
+            .map((s) => s.file_path);
+        return {
+            agent_id: agentId,
+            modules: overlapping,
+            recent_files: [...new Set(recentFiles)],
+            action_summaries: summaries,
+        };
+    }
+}

package/dist/src/database.d.ts

@@ -0,0 +1,4 @@
+import type { DatabaseAdapter } from "./db-adapter.js";
+export declare function initDatabase(dataDir: string): void;
+export declare function getDb(): DatabaseAdapter;
+export declare function closeDb(): void;