minutes-mcp 0.5.0

package/dist/index.js

@@ -0,0 +1,812 @@
+#!/usr/bin/env node
+/**
+ * Minutes MCP Server
+ *
+ * MCP tools for Claude Desktop / Cowork / Dispatch:
+ *   - start_recording: Start recording audio from the default input device
+ *   - stop_recording: Stop recording and process through the pipeline
+ *   - get_status: Check if a recording is in progress
+ *   - list_meetings: List recent meetings and voice memos
+ *   - search_meetings: Search meeting transcripts
+ *   - get_meeting: Get full transcript of a specific meeting
+ *   - process_audio: Process an audio file through the pipeline
+ *   - add_note: Add a timestamped note to a recording or meeting
+ *   - consistency_report: Flag conflicting decisions and stale commitments
+ *   - get_person_profile: Build a profile for a person across meetings
+ *   - research_topic: Cross-meeting topic research
+ *   - qmd_collection_status: Check QMD collection registration
+ *   - register_qmd_collection: Register Minutes output as QMD collection
+ *
+ * All tools use execFile (not exec) to shell out to the `minutes` CLI binary.
+ * No shell interpolation — safe from injection.
+ */
+import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { registerAppTool, registerAppResource, RESOURCE_MIME_TYPE, } from "@modelcontextprotocol/ext-apps/server";
+import { z } from "zod";
+import { execFile, spawn } from "child_process";
+import { promisify } from "util";
+import { existsSync, realpathSync } from "fs";
+import { readFile } from "fs/promises";
+import { dirname, extname, join, resolve } from "path";
+import { fileURLToPath } from "url";
+import { homedir } from "os";
+const UI_RESOURCE_URI = "ui://minutes/dashboard";
+const execFileAsync = promisify(execFile);
+// ── QMD semantic search (optional — falls back to CLI) ──────
+let qmdAvailable = null;
+async function runQmd(args, timeoutMs = 15000) {
+    try {
+        const { stdout, stderr } = await execFileAsync("qmd", args, {
+            timeout: timeoutMs,
+            env: { ...process.env },
+        });
+        return { stdout: stdout.trim(), stderr: stderr.trim() };
+    }
+    catch {
+        return null;
+    }
+}
+async function isQmdAvailable() {
+    if (qmdAvailable !== null)
+        return qmdAvailable;
+    const result = await runQmd(["collection", "show", "minutes"]);
+    qmdAvailable = result !== null && !result.stderr.includes("not found") && !result.stderr.includes("No collection");
+    if (qmdAvailable) {
+        console.error("[Minutes] QMD available — semantic search enabled for minutes collection");
+    }
+    return qmdAvailable;
+}
+async function enrichWithFrontmatter(qmdResults) {
+    return Promise.all(qmdResults.map(async (r) => {
+        try {
+            const head = (await readFile(r.source_path || r.path, "utf-8")).slice(0, 600);
+            const title = head.match(/^title:\s*(.+)$/m)?.[1]?.trim() || "";
+            const date = head.match(/^date:\s*(.+)$/m)?.[1]?.trim() || "";
+            const contentType = head.match(/^type:\s*(.+)$/m)?.[1]?.trim() || "meeting";
+            return {
+                date,
+                title,
+                content_type: contentType,
+                path: r.source_path || r.path,
+                snippet: r.snippet || "",
+            };
+        }
+        catch {
+            return {
+                date: "",
+                title: "",
+                content_type: "meeting",
+                path: r.source_path || r.path,
+                snippet: r.snippet || "",
+            };
+        }
+    }));
+}
+async function searchViaQmd(query, limit, contentType) {
+    if (!(await isQmdAvailable()))
+        return null;
+    const args = ["search", query, "-c", "minutes", "-n", String(limit), "--json"];
+    const result = await runQmd(args);
+    if (!result)
+        return null;
+    try {
+        const parsed = JSON.parse(result.stdout);
+        const results = Array.isArray(parsed) ? parsed : parsed.results || [];
+        if (results.length === 0)
+            return null;
+        const enriched = await enrichWithFrontmatter(results);
+        // Apply content type filter if specified
+        if (contentType) {
+            const filtered = enriched.filter((r) => r.content_type === contentType);
+            return filtered.length > 0 ? filtered : null;
+        }
+        return enriched;
+    }
+    catch {
+        return null;
+    }
+}
+async function triggerQmdIndex() {
+    if (!(await isQmdAvailable()))
+        return;
+    // Fire-and-forget — don't block the response
+    execFileAsync("qmd", ["update", "-c", "minutes"]).catch(() => { });
+}
+// ESM-compatible __dirname
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// ── Find the minutes binary ─────────────────────────────────
+function findMinutesBinary() {
+    const isWindows = process.platform === "win32";
+    const ext = isWindows ? ".exe" : "";
+    const candidates = [
+        join(__dirname, "..", "..", "..", "target", "release", `minutes${ext}`),
+        join(__dirname, "..", "..", "..", "target", "debug", `minutes${ext}`),
+        join(homedir(), ".cargo", "bin", `minutes${ext}`),
+        ...(isWindows
+            ? []
+            : [
+                join(homedir(), ".local", "bin", "minutes"),
+                "/opt/homebrew/bin/minutes",
+                "/usr/local/bin/minutes",
+            ]),
+    ];
+    for (const candidate of candidates) {
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    // Fall back to PATH lookup
+    return "minutes";
+}
+const MINUTES_BIN = findMinutesBinary();
+// ── Helper: run minutes CLI command (uses execFile, not exec) ──
+async function runMinutes(args, timeoutMs = 30000) {
+    try {
+        const { stdout, stderr } = await execFileAsync(MINUTES_BIN, args, {
+            timeout: timeoutMs,
+            env: { ...process.env, RUST_LOG: "info" },
+        });
+        return { stdout: stdout.trim(), stderr: stderr.trim() };
+    }
+    catch (error) {
+        if (error.killed) {
+            throw new Error(`Command timed out after ${timeoutMs}ms`);
+        }
+        const stderr = error.stderr?.trim() || "";
+        const stdout = error.stdout?.trim() || "";
+        throw new Error(stderr || stdout || error.message);
+    }
+}
+function parseJsonOutput(stdout) {
+    try {
+        return JSON.parse(stdout);
+    }
+    catch {
+        return { raw: stdout };
+    }
+}
+function canonicalizeFilePath(path) {
+    if (!existsSync(path)) {
+        throw new Error(`Path does not exist: ${path}`);
+    }
+    return realpathSync(path);
+}
+function canonicalizeRoot(root) {
+    // Roots may not exist yet (e.g. ~/.minutes/inbox on first run).
+    // Use realpath if it exists, otherwise lexical resolve.
+    return existsSync(root) ? realpathSync(root) : resolve(root);
+}
+function isWithinDirectory(candidate, root) {
+    // Ensure root ends with separator to prevent prefix attacks (e.g. ~/meetings-evil)
+    const rootWithSep = root.endsWith("/") ? root : root + "/";
+    return candidate === root || candidate.startsWith(rootWithSep);
+}
+function validatePathInDirectory(path, root, allowedExts) {
+    const canonicalPath = canonicalizeFilePath(path);
+    const canonicalRoot = canonicalizeRoot(root);
+    if (!allowedExts.includes(extname(canonicalPath).toLowerCase())) {
+        throw new Error(`Access denied: path must be within ${canonicalRoot} and end with ${allowedExts.join(", ")}`);
+    }
+    if (!isWithinDirectory(canonicalPath, canonicalRoot)) {
+        throw new Error(`Access denied: path must be within ${canonicalRoot}`);
+    }
+    return canonicalPath;
+}
+function validatePathInDirectories(path, roots, allowedExts) {
+    const canonicalPath = canonicalizeFilePath(path);
+    if (!allowedExts.includes(extname(canonicalPath).toLowerCase())) {
+        throw new Error(`Access denied: path must end with one of ${allowedExts.join(", ")}`);
+    }
+    const canonicalRoots = roots.map((root) => canonicalizeRoot(root));
+    if (!canonicalRoots.some((root) => isWithinDirectory(canonicalPath, root))) {
+        throw new Error(`Access denied: file must be inside one of ${canonicalRoots.join(", ")}`);
+    }
+    return canonicalPath;
+}
+// ── MCP Server ──────────────────────────────────────────────
+const server = new McpServer({
+    name: "minutes",
+    version: "0.3.0",
+});
+// Configurable directories — override via env vars in Claude Desktop extension settings
+const MEETINGS_DIR = process.env.MEETINGS_DIR || join(homedir(), "meetings");
+const MINUTES_HOME = process.env.MINUTES_HOME || join(homedir(), ".minutes");
+// ── UI Resource: MCP App dashboard ──────────────────────────
+registerAppResource(server, "Minutes Dashboard", UI_RESOURCE_URI, { description: "Interactive meeting dashboard and detail viewer" }, async () => {
+    const htmlPath = join(__dirname, "..", "dist-ui", "index.html");
+    const html = await readFile(htmlPath, "utf-8");
+    return {
+        contents: [{
+                uri: UI_RESOURCE_URI,
+                mimeType: RESOURCE_MIME_TYPE,
+                text: html,
+            }],
+    };
+});
+// ── Tool: start_recording ───────────────────────────────────
+server.tool("start_recording", "Start recording audio from the default input device. The recording runs until stop_recording is called.", {
+    title: z.string().optional().describe("Optional title for this recording"),
+    mode: z
+        .enum(["meeting", "quick-thought"])
+        .optional()
+        .default("meeting")
+        .describe("Live capture mode"),
+}, { title: "Start Recording", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false }, async ({ title, mode }) => {
+    const { stdout: statusOut } = await runMinutes(["status"]);
+    const status = parseJsonOutput(statusOut);
+    if (status.recording) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Already recording (PID: ${status.pid}). Run stop_recording first.`,
+                },
+            ],
+        };
+    }
+    // Spawn detached — recording is a foreground process that blocks,
+    // so we spawn it and let it run independently
+    const args = ["record", "--mode", mode];
+    if (title)
+        args.push("--title", title);
+    const child = spawn(MINUTES_BIN, args, {
+        detached: true,
+        stdio: "ignore",
+        env: { ...process.env, RUST_LOG: "info" },
+    });
+    child.unref();
+    // Wait for PID file to appear
+    await new Promise((r) => setTimeout(r, 1000));
+    const { stdout: newStatus } = await runMinutes(["status"]);
+    const result = parseJsonOutput(newStatus);
+    return {
+        content: [
+            {
+                type: "text",
+                text: result.recording
+                    ? `${result.recording_mode === "quick-thought" ? "Quick thought" : "Recording"} started (PID: ${result.pid}). Say "stop recording" when done.`
+                    : "Recording failed to start. Check `minutes logs` for details.",
+            },
+        ],
+    };
+});
+// ── Tool: stop_recording ────────────────────────────────────
+server.tool("stop_recording", "Stop the current recording and process it (transcribe, diarize, summarize).", {}, { title: "Stop Recording", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false }, async () => {
+    try {
+        const { stdout, stderr } = await runMinutes(["stop"], 180000);
+        const result = parseJsonOutput(stdout);
+        const message = result.file
+            ? `Recording saved: ${result.file}\nTitle: ${result.title}\nWords: ${result.words}`
+            : stderr || "Recording stopped.";
+        // Trigger QMD re-index so new meeting is immediately searchable
+        if (result.file)
+            triggerQmdIndex();
+        return { content: [{ type: "text", text: message }] };
+    }
+    catch (error) {
+        return {
+            content: [{ type: "text", text: `Stop failed: ${error.message}` }],
+        };
+    }
+});
+// ── Tool: get_status ────────────────────────────────────────
+server.tool("get_status", "Check if a recording is currently in progress.", {}, { title: "Recording Status", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }, async () => {
+    const { stdout } = await runMinutes(["status"]);
+    const status = parseJsonOutput(stdout);
+    const modeLabel = status.recording_mode === "quick-thought" ? "Quick thought" : "Recording";
+    const processingLabel = status.recording_mode === "quick-thought" ? "Quick thought processing" : "Processing";
+    const text = status.recording
+        ? `${modeLabel} in progress (PID: ${status.pid})`
+        : status.processing
+            ? `${processingLabel}${status.processing_stage ? `: ${status.processing_stage}` : "."}`
+            : "No recording in progress.";
+    return { content: [{ type: "text", text }] };
+});
+// ── Tool: list_meetings ─────────────────────────────────────
+registerAppTool(server, "list_meetings", {
+    description: "List recent meetings and voice memos.",
+    inputSchema: {
+        limit: z.number().optional().default(10).describe("Maximum results"),
+        type: z.enum(["meeting", "memo"]).optional().describe("Filter by type"),
+    },
+    annotations: { title: "List Meetings", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    _meta: { ui: { resourceUri: UI_RESOURCE_URI } },
+}, async ({ limit, type: contentType }) => {
+    const args = ["list", "--limit", String(limit)];
+    if (contentType)
+        args.push("-t", contentType);
+    // Fetch meetings and action items in parallel
+    const [meetingsResult, actionsResult] = await Promise.all([
+        runMinutes(args),
+        runMinutes(["search", "", "--intents-only", "--intent-kind", "action-item", "--limit", "20"]).catch(() => ({ stdout: "[]", stderr: "" })),
+    ]);
+    const meetings = parseJsonOutput(meetingsResult.stdout);
+    let actions = [];
+    const parsedActions = parseJsonOutput(actionsResult.stdout);
+    if (Array.isArray(parsedActions))
+        actions = parsedActions;
+    if (Array.isArray(meetings) && meetings.length === 0) {
+        return {
+            content: [{ type: "text", text: "No meetings or memos found." }],
+            structuredContent: { meetings: [], actions, view: "dashboard" },
+            _meta: { ui: { resourceUri: UI_RESOURCE_URI }, view: "dashboard" },
+        };
+    }
+    const text = Array.isArray(meetings)
+        ? meetings
+            .map((m) => `${m.date} — ${m.title} [${m.content_type}]\n  ${m.path}`)
+            .join("\n\n")
+        : (meetingsResult.stderr || meetingsResult.stdout);
+    return {
+        content: [{ type: "text", text }],
+        structuredContent: { meetings: Array.isArray(meetings) ? meetings : [], actions, view: "dashboard" },
+        _meta: { ui: { resourceUri: UI_RESOURCE_URI }, view: "dashboard" },
+    };
+});
+// ── Tool: search_meetings ───────────────────────────────────
+registerAppTool(server, "search_meetings", {
+    description: "Search meeting transcripts and voice memos.",
+    inputSchema: {
+        query: z.string().describe("Text to search for"),
+        type: z.enum(["meeting", "memo"]).optional().describe("Filter by type"),
+        since: z.string().optional().describe("Only results after this date (ISO)"),
+        limit: z.number().optional().default(10).describe("Maximum results"),
+        intent_kind: z
+            .enum(["action-item", "decision", "open-question", "commitment"])
+            .optional()
+            .describe("Filter structured intents by kind"),
+        owner: z.string().optional().describe("Filter structured intents by owner / person"),
+        intents_only: z
+            .boolean()
+            .optional()
+            .default(false)
+            .describe("Return structured intent records instead of transcript snippets"),
+    },
+    annotations: { title: "Search Meetings", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    _meta: { ui: { resourceUri: UI_RESOURCE_URI } },
+}, async ({ query, type: contentType, since, limit, intent_kind, owner, intents_only }) => {
+    // Intent/metadata queries always use CLI (QMD doesn't index YAML frontmatter fields)
+    const useCliOnly = intents_only || intent_kind || owner || since;
+    // Try QMD semantic search for text queries
+    let results = null;
+    let usedQmd = false;
+    if (!useCliOnly) {
+        results = await searchViaQmd(query, limit, contentType);
+        if (results)
+            usedQmd = true;
+    }
+    // Fall back to CLI regex search
+    if (!results) {
+        const args = ["search", query, "--limit", String(limit)];
+        if (contentType)
+            args.push("-t", contentType);
+        if (since)
+            args.push("--since", since);
+        if (intent_kind)
+            args.push("--intent-kind", intent_kind);
+        if (owner)
+            args.push("--owner", owner);
+        if (intents_only)
+            args.push("--intents-only");
+        const { stdout, stderr } = await runMinutes(args);
+        const parsed = parseJsonOutput(stdout);
+        results = Array.isArray(parsed) ? parsed : [];
+    }
+    if (results.length === 0) {
+        return {
+            content: [{ type: "text", text: `No results found for "${query}".` }],
+            structuredContent: { meetings: [], actions: [], view: "dashboard" },
+            _meta: { ui: { resourceUri: UI_RESOURCE_URI }, view: "dashboard" },
+        };
+    }
+    const text = intents_only
+        ? results
+            .map((r) => `${r.date} — ${r.title} [${r.content_type}]\n  ${r.kind}: ${r.what}${r.who ? ` (@${r.who})` : ""}${r.by_date ? ` by ${r.by_date}` : ""}\n  ${r.path}`)
+            .join("\n\n")
+        : results
+            .map((r) => `${r.date} — ${r.title} [${r.content_type}]\n  ${r.snippet}\n  ${r.path}`)
+            .join("\n\n");
+    // Map search results to meeting-like objects for the dashboard view
+    const meetings = results.map((r) => ({
+        date: r.date,
+        title: r.title,
+        content_type: r.content_type,
+        path: r.path,
+        snippet: r.snippet || (intents_only ? `${r.kind}: ${r.what}` : undefined),
+    }));
+    return {
+        content: [{ type: "text", text }],
+        structuredContent: { meetings, actions: [], view: "dashboard" },
+        _meta: { ui: { resourceUri: UI_RESOURCE_URI }, view: "dashboard" },
+    };
+});
+// ── Tool: consistency_report ───────────────────────────────
+registerAppTool(server, "consistency_report", {
+    description: "Flag conflicting decisions and stale commitments across meetings using structured intent data.",
+    inputSchema: {
+        owner: z.string().optional().describe("Filter stale commitments by owner / person"),
+        stale_after_days: z
+            .number()
+            .optional()
+            .default(7)
+            .describe("Flag commitments this many days old or older"),
+    },
+    annotations: { title: "Consistency Report", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    _meta: { ui: { resourceUri: UI_RESOURCE_URI } },
+}, async ({ owner, stale_after_days }) => {
+    const args = ["consistency", "--stale-after-days", String(stale_after_days)];
+    if (owner)
+        args.push("--owner", owner);
+    const { stdout, stderr } = await runMinutes(args);
+    const report = parseJsonOutput(stdout);
+    if (!report || typeof report !== "object") {
+        return { content: [{ type: "text", text: stderr || stdout }] };
+    }
+    const decisionConflicts = Array.isArray(report.decision_conflicts)
+        ? report.decision_conflicts
+        : [];
+    const staleCommitments = Array.isArray(report.stale_commitments)
+        ? report.stale_commitments
+        : [];
+    if (decisionConflicts.length === 0 && staleCommitments.length === 0) {
+        return {
+            content: [{ type: "text", text: "No consistency issues found." }],
+            structuredContent: { decision_conflicts: [], stale_commitments: [], view: "report" },
+            _meta: { ui: { resourceUri: UI_RESOURCE_URI }, view: "report" },
+        };
+    }
+    const sections = [];
+    if (decisionConflicts.length > 0) {
+        sections.push("Decision conflicts:\n" +
+            decisionConflicts
+                .map((conflict) => `- ${conflict.topic}: latest "${conflict.latest.what}" (${conflict.latest.title})`)
+                .join("\n"));
+    }
+    if (staleCommitments.length > 0) {
+        sections.push("Stale commitments:\n" +
+            staleCommitments
+                .map((stale) => `- ${stale.kind}: ${stale.entry.what}${stale.entry.who ? ` (@${stale.entry.who})` : ""} — ${Array.isArray(stale.reasons) ? stale.reasons.join(", ") : `${stale.age_days} days old`}${stale.latest_follow_up ? `; latest follow-up: ${stale.latest_follow_up.title}` : ""}`)
+                .join("\n"));
+    }
+    return {
+        content: [{ type: "text", text: sections.join("\n\n") }],
+        structuredContent: { decision_conflicts: decisionConflicts, stale_commitments: staleCommitments, view: "report" },
+        _meta: { ui: { resourceUri: UI_RESOURCE_URI }, view: "report" },
+    };
+});
+// ── Tool: get_person_profile ───────────────────────────────
+registerAppTool(server, "get_person_profile", {
+    description: "Build a first-pass profile for a person across meetings using structured intent data.",
+    inputSchema: {
+        name: z.string().describe("Person / attendee name to profile"),
+    },
+    annotations: { title: "Person Profile", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    _meta: { ui: { resourceUri: UI_RESOURCE_URI } },
+}, async ({ name }) => {
+    const { stdout, stderr } = await runMinutes(["person", name]);
+    const profile = parseJsonOutput(stdout);
+    if (!profile || typeof profile !== "object") {
+        return { content: [{ type: "text", text: stderr || stdout }] };
+    }
+    const topics = Array.isArray(profile.top_topics) ? profile.top_topics : [];
+    const openIntents = Array.isArray(profile.open_intents) ? profile.open_intents : [];
+    const recentMeetings = Array.isArray(profile.recent_meetings)
+        ? profile.recent_meetings
+        : [];
+    if (topics.length === 0 && openIntents.length === 0 && recentMeetings.length === 0) {
+        return {
+            content: [{ type: "text", text: `No profile data found for ${name}.` }],
+            structuredContent: { name, top_topics: [], open_intents: [], recent_meetings: [], view: "person" },
+            _meta: { ui: { resourceUri: UI_RESOURCE_URI }, view: "person" },
+        };
+    }
+    const sections = [];
+    if (topics.length > 0) {
+        sections.push("Top topics:\n" +
+            topics.map((topic) => `- ${topic.topic} (${topic.count})`).join("\n"));
+    }
+    if (openIntents.length > 0) {
+        sections.push("Open commitments/actions:\n" +
+            openIntents
+                .map((intent) => `- ${intent.kind}: ${intent.what}${intent.by_date ? ` by ${intent.by_date}` : ""}`)
+                .join("\n"));
+    }
+    if (recentMeetings.length > 0) {
+        sections.push("Recent meetings:\n" +
+            recentMeetings
+                .map((meeting) => `- ${meeting.date} — ${meeting.title}`)
+                .join("\n"));
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: `Profile for ${profile.name}:\n\n${sections.join("\n\n")}`,
+            },
+        ],
+        structuredContent: { ...profile, view: "person" },
+        _meta: { ui: { resourceUri: UI_RESOURCE_URI }, view: "person" },
+    };
+});
+// ── Tool: research_topic ────────────────────────────────────
+server.tool("research_topic", "Research a topic across meetings, decisions, and open follow-ups.", {
+    query: z.string().describe("Topic or question to investigate across meetings"),
+    type: z.enum(["meeting", "memo"]).optional().describe("Filter by type"),
+    since: z.string().optional().describe("Only results after this date (ISO)"),
+    attendee: z.string().optional().describe("Filter by attendee / person"),
+}, { title: "Research Topic", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }, async ({ query, type: contentType, since, attendee }) => {
+    const args = ["research", query];
+    if (contentType)
+        args.push("-t", contentType);
+    if (since)
+        args.push("--since", since);
+    if (attendee)
+        args.push("--attendee", attendee);
+    const { stdout, stderr } = await runMinutes(args);
+    const report = parseJsonOutput(stdout);
+    if (!report || typeof report !== "object") {
+        return { content: [{ type: "text", text: stderr || stdout }] };
+    }
+    const decisions = Array.isArray(report.related_decisions) ? report.related_decisions : [];
+    const openIntents = Array.isArray(report.related_open_intents)
+        ? report.related_open_intents
+        : [];
+    const recentMeetings = Array.isArray(report.recent_meetings)
+        ? report.recent_meetings
+        : [];
+    const topics = Array.isArray(report.related_topics) ? report.related_topics : [];
+    if (decisions.length === 0 && openIntents.length === 0 && recentMeetings.length === 0) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `No cross-meeting results found for ${query}.`,
+                },
+            ],
+        };
+    }
+    const sections = [];
+    if (topics.length > 0) {
+        sections.push("Related topics:\n" +
+            topics.map((topic) => `- ${topic.topic} (${topic.count})`).join("\n"));
+    }
+    if (decisions.length > 0) {
+        sections.push("Recent decisions:\n" +
+            decisions
+                .map((decision) => `- ${decision.date} — ${decision.what} (${decision.title})`)
+                .join("\n"));
+    }
+    if (openIntents.length > 0) {
+        sections.push("Open follow-ups:\n" +
+            openIntents
+                .map((intent) => `- ${intent.kind}: ${intent.what}${intent.who ? ` (@${intent.who})` : ""}${intent.by_date ? ` by ${intent.by_date}` : ""}`)
+                .join("\n"));
+    }
+    if (recentMeetings.length > 0) {
+        sections.push("Matching meetings:\n" +
+            recentMeetings
+                .map((meeting) => `- ${meeting.date} — ${meeting.title}`)
+                .join("\n"));
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: `Cross-meeting research for ${query}:\n\n${sections.join("\n\n")}`,
+            },
+        ],
+    };
+});
+// ── Tool: get_meeting ───────────────────────────────────────
+registerAppTool(server, "get_meeting", {
+    description: "Get the full transcript and details of a specific meeting or memo.",
+    inputSchema: {
+        path: z.string().describe("Path to the meeting markdown file"),
+    },
+    annotations: { title: "View Meeting", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+    _meta: { ui: { resourceUri: UI_RESOURCE_URI } },
+}, async ({ path: filePath }) => {
+    try {
+        const resolved = validatePathInDirectory(filePath, MEETINGS_DIR, [".md"]);
+        const content = await readFile(resolved, "utf-8");
+        return {
+            content: [{ type: "text", text: content }],
+            structuredContent: { path: resolved, view: "detail" },
+            _meta: { ui: { resourceUri: UI_RESOURCE_URI }, view: "detail", path: resolved },
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: "text", text: `Could not read: ${error.message}` }],
+        };
+    }
+});
+// ── Tool: process_audio ─────────────────────────────────────
+server.tool("process_audio", "Process an audio file through the transcription pipeline.", {
+    file_path: z.string().describe("Path to audio file (.wav, .m4a, .mp3)"),
+    type: z.enum(["meeting", "memo"]).optional().default("memo").describe("Content type"),
+    title: z.string().optional().describe("Optional title"),
+}, { title: "Process Audio", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false }, async ({ file_path, type: contentType, title }) => {
+    const allowedDirs = [
+        join(MINUTES_HOME, "inbox"),
+        MEETINGS_DIR,
+        join(homedir(), "Downloads"),
+    ];
+    const audioExts = [".wav", ".m4a", ".mp3", ".ogg", ".webm"];
+    try {
+        const resolved = validatePathInDirectories(file_path, allowedDirs, audioExts);
+        const args = ["process", resolved, "-t", contentType];
+        if (title)
+            args.push("--title", title);
+        const { stdout } = await runMinutes(args, 300000);
+        const result = parseJsonOutput(stdout);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: result.file
+                        ? `Processed: ${result.file}\nTitle: ${result.title}\nWords: ${result.words}`
+                        : stdout,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: "text", text: `Failed: ${error.message}` }],
+        };
+    }
+});
+// ── Tool: add_note ───────────────────────────────────────────
+server.tool("add_note", "Add a note to the current recording. Notes are timestamped and included in the meeting summary. If no recording is active, annotate an existing meeting file with --meeting.", {
+    text: z.string().describe("The note text (plain text, no markdown needed)"),
+    meeting_path: z
+        .string()
+        .optional()
+        .describe("Path to an existing meeting file to annotate (for post-meeting notes)"),
+}, { title: "Add Note", readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false }, async ({ text, meeting_path }) => {
+    try {
+        const args = ["note", text];
+        if (meeting_path) {
+            const resolved = validatePathInDirectory(meeting_path, MEETINGS_DIR, [".md"]);
+            args.push("--meeting", resolved);
+        }
+        const { stdout, stderr } = await runMinutes(args);
+        return {
+            content: [{ type: "text", text: stderr || stdout || "Note added." }],
+        };
+    }
+    catch (error) {
+        return {
+            content: [{ type: "text", text: `Note failed: ${error.message}` }],
+        };
+    }
+});
+// ── Tool: qmd_collection_status ─────────────────────────────
+server.tool("qmd_collection_status", "Check whether the Minutes output directory is already registered as a QMD collection.", {
+    collection: z
+        .string()
+        .optional()
+        .default("minutes")
+        .describe("QMD collection name to check"),
+}, { title: "QMD Status", readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false }, async ({ collection }) => {
+    const { stdout, stderr } = await runMinutes([
+        "qmd",
+        "status",
+        "--collection",
+        collection,
+    ]);
+    const report = parseJsonOutput(stdout);
+    if (!report || typeof report !== "object") {
+        return { content: [{ type: "text", text: stderr || stdout }] };
+    }
+    if (!report.qmd_available) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `QMD is not installed or not on PATH. Install qmd, then run register_qmd_collection for "${collection}".`,
+                },
+            ],
+        };
+    }
+    if (report.registered) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `QMD collection "${collection}" already indexes ${report.output_dir}.`,
+                },
+            ],
+        };
+    }
+    const aliases = Array.isArray(report.matching_collections)
+        ? report.matching_collections.map((candidate) => candidate.name)
+        : [];
+    return {
+        content: [
+            {
+                type: "text",
+                text: aliases.length > 0
+                    ? `${report.output_dir} is already indexed in QMD under: ${aliases.join(", ")}.`
+                    : `${report.output_dir} is not indexed in QMD yet.`,
+            },
+        ],
+    };
+});
+// ── Tool: register_qmd_collection ───────────────────────────
+server.tool("register_qmd_collection", "Register the Minutes output directory as a QMD collection.", {
+    collection: z
+        .string()
+        .optional()
+        .default("minutes")
+        .describe("QMD collection name to register"),
+}, { title: "Register QMD", readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: false }, async ({ collection }) => {
+    const { stdout, stderr } = await runMinutes([
+        "qmd",
+        "register",
+        "--collection",
+        collection,
+    ]);
+    const report = parseJsonOutput(stdout);
+    if (!report || typeof report !== "object") {
+        return { content: [{ type: "text", text: stderr || stdout }] };
+    }
+    if (!report.registered) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: stderr || stdout || `Failed to register QMD collection "${collection}".`,
+                },
+            ],
+        };
+    }
+    return {
+        content: [
+            {
+                type: "text",
+                text: `Registered ${report.output_dir} as QMD collection "${collection}".`,
+            },
+        ],
+    };
+});
+// ── Resources ───────────────────────────────────────────────
+server.resource("recent_meetings", "minutes://meetings/recent", { description: "List of recent meetings and memos" }, async () => {
+    const { stdout } = await runMinutes(["list", "--limit", "20"]);
+    return { contents: [{ uri: "minutes://meetings/recent", mimeType: "application/json", text: stdout }] };
+});
+server.resource("recording_status", "minutes://status", { description: "Current recording status" }, async () => {
+    const { stdout } = await runMinutes(["status"]);
+    return { contents: [{ uri: "minutes://status", mimeType: "application/json", text: stdout }] };
+});
+server.resource("open_actions", "minutes://actions/open", { description: "All open action items across meetings" }, async () => {
+    const { stdout } = await runMinutes(["search", "", "--intents-only", "--intent-kind", "action-item"]);
+    return { contents: [{ uri: "minutes://actions/open", mimeType: "application/json", text: stdout }] };
+});
+server.resource("recent_events", "minutes://events/recent", { description: "Recent pipeline events (recordings, processing, notes)" }, async () => {
+    const { stdout } = await runMinutes(["events", "--limit", "20"]);
+    return { contents: [{ uri: "minutes://events/recent", mimeType: "application/json", text: stdout }] };
+});
+server.resource("meeting", new ResourceTemplate("minutes://meetings/{slug}", { list: undefined }), { description: "Get a specific meeting by its filename slug" }, async (uri, variables) => {
+    const slug = String(variables.slug);
+    const { stdout } = await runMinutes(["resolve", slug]);
+    const parsed = parseJsonOutput(stdout);
+    if (parsed.path) {
+        const content = await readFile(parsed.path, "utf-8");
+        return { contents: [{ uri: uri.href, mimeType: "text/markdown", text: content }] };
+    }
+    return { contents: [{ uri: uri.href, mimeType: "text/plain", text: `Meeting not found: ${slug}` }] };
+});
+// ── Start server ────────────────────────────────────────────
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("Minutes MCP server running on stdio");
+}
+main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});