@noelclaw/mcp 2.3.0 → 2.4.0

package/dist/tools/memory.js

@@ -1,82 +1,54 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MEMORY_TOOLS = exports.SM_SPACE = void 0;
-exports.smFetch = smFetch;
+exports.MEMORY_TOOLS = void 0;
 exports.syncToSupermemory = syncToSupermemory;
 exports.searchSupermemory = searchSupermemory;
 exports.handleMemoryTool = handleMemoryTool;
 const zod_1 = require("zod");
-const SM_BASE = "https://api.supermemory.ai/v3";
-exports.SM_SPACE = "noelclaw-vault";
-// ─── Supermemory HTTP helpers ────────────────────────────────────────────────
-async function smFetch(path, method, body) {
-    const apiKey = process.env.SUPERMEMORY_API_KEY;
-    if (!apiKey)
-        return { ok: false, data: null, error: "SUPERMEMORY_API_KEY not set" };
-    try {
-        const res = await fetch(`${SM_BASE}${path}`, {
-            method,
-            headers: {
-                Authorization: `Bearer ${apiKey}`,
-                "Content-Type": "application/json",
-            },
-            body: body ? JSON.stringify(body) : undefined,
-            signal: AbortSignal.timeout(15000),
-        });
-        if (!res.ok) {
-            const err = await res.text().catch(() => "");
-            return { ok: false, data: null, error: `${res.status}: ${err.slice(0, 120)}` };
-        }
-        return { ok: true, data: await res.json() };
-    }
-    catch (err) {
-        return { ok: false, data: null, error: err.message };
-    }
-}
+const convex_js_1 = require("../convex.js");
+// ─── Helpers (proxied through Convex — server-side Supermemory key) ──────────
 async function syncToSupermemory(content, metadata, sourceUrl) {
-    await smFetch("/memories", "POST", {
+    await (0, convex_js_1.callConvex)("/memory/add", "POST", {
         content,
         metadata,
-        spaces: [exports.SM_SPACE],
         ...(sourceUrl ? { sourceUrl } : {}),
-    });
+    }).catch(() => { });
 }
 async function searchSupermemory(query, limit = 10) {
-    const { ok, data } = await smFetch("/search", "POST", {
-        q: query,
-        n: limit,
-        spaces: [exports.SM_SPACE],
-        returnContext: true,
-    });
-    if (!ok || !data?.results)
+    try {
+        const data = await (0, convex_js_1.callConvex)("/memory/search", "POST", { q: query, n: limit });
+        return data?.results ?? [];
+    }
+    catch {
         return [];
-    return data.results;
+    }
 }
 // ─── Tool definitions ────────────────────────────────────────────────────────
 exports.MEMORY_TOOLS = [
     {
         name: "memory_add",
-        description: "Add content to Noelclaw's semantic memory layer (powered by Supermemory). " +
-            "Unlike vault_save, memory_add is quick — no versioning, no type required. " +
-            "Use this for notes, decisions, preferences, URLs, or anything you want to " +
-            "find later with natural language search. Memory is indexed semantically — " +
-            "'what did I say about ETH yield?' will find it even without exact keywords.",
+        description: "Add content to your Noelclaw semantic memory — no setup needed, no extra API keys. " +
+            "Unlike vault_save, memory_add is instant: no versioning, no type required. " +
+            "Use for notes, decisions, preferences, or anything you want to find later with natural language. " +
+            "Pass sourceUrl to fetch and index any web page, GitHub repo, or Notion page automatically — " +
+            "searchable in ~30s. Memory is indexed semantically — 'what did I say about ETH yield?' " +
+            "will find it even without exact keywords.",
         inputSchema: {
             type: "object",
             properties: {
-                content: { type: "string", description: "Content to remember — text, markdown, or a note" },
+                content: { type: "string", description: "Content to remember — text, markdown, or a note. Use a short title if providing sourceUrl." },
                 title: { type: "string", description: "Optional title for this memory" },
                 tags: { type: "array", items: { type: "string" }, description: "Tags for grouping" },
-                sourceUrl: { type: "string", description: "Optional URL — if provided, Supermemory also fetches and indexes the page content" },
+                sourceUrl: { type: "string", description: "URL to fetch and index automatically (GitHub, Notion, web page, etc.). Content becomes searchable in ~30s." },
             },
             required: ["content"],
         },
     },
     {
         name: "memory_search",
-        description: "Semantic search across all Noelclaw memories. Unlike keyword search, this " +
-            "understands meaning — 'low risk crypto yield' will match 'conservative DeFi strategies'. " +
-            "Also searches memories synced from vault_save and vault_remember automatically.",
+        description: "Semantic search across all your Noelclaw memories. Understands meaning, not just keywords — " +
+            "'low risk crypto yield' matches 'conservative DeFi strategies'. " +
+            "Also searches memories auto-synced from vault_save.",
         inputSchema: {
             type: "object",
             properties: {
@@ -88,10 +60,9 @@ exports.MEMORY_TOOLS = [
     },
     {
         name: "memory_context",
-        description: "Retrieve the most semantically relevant memories for a topic and format them " +
-            "as ready-to-inject context. Use at the start of research tasks to prime with " +
-            "everything stored about a topic. Smarter than vault_context — uses vector search, " +
-            "not just keyword matching.",
+        description: "Retrieve the most semantically relevant memories for a topic, formatted as AI-ready context. " +
+            "Use at the start of research tasks to prime with everything stored about a topic. " +
+            "Uses vector search — finds semantically related content, not just exact keyword matches.",
         inputSchema: {
             type: "object",
             properties: {
@@ -103,8 +74,8 @@ exports.MEMORY_TOOLS = [
     },
     {
         name: "memory_profile",
-        description: "Show your semantic memory stats — how many memories, recent additions, and " +
-            "connected data sources. Useful for auditing what Noelclaw knows about you.",
+        description: "Show your semantic memory stats — total memories stored, your memory space, and connected sources. " +
+            "Useful for auditing what Noelclaw knows about you.",
         inputSchema: {
             type: "object",
             properties: {},
@@ -112,33 +83,44 @@ exports.MEMORY_TOOLS = [
         },
     },
     {
-        name: "memory_connect",
-        description: "Connect an external data source to Noelclaw's semantic memory, or add content " +
-            "from a specific URL. Supported sources:\n" +
-            "- url: fetch and index any web page or GitHub file\n" +
-            "- github: index a GitHub repository README/docs\n" +
-            "- notion: add content from a public Notion page URL\n" +
-            "- manual: paste content directly (same as memory_add with sourceUrl)\n" +
-            "For Google Drive, Gmail, and full Notion sync, connect via your Noelclaw dashboard.",
+        name: "memory_list",
+        description: "List your most recent Noelclaw memories without a search query. " +
+            "Useful to browse what's stored or audit before clearing. " +
+            "Sorted by most recently added.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                limit: { type: "number", description: "Max memories to return (default 20)" },
+                tag: { type: "string", description: "Optional: filter by tag" },
+            },
+            required: [],
+        },
+    },
+    {
+        name: "memory_delete",
+        description: "Delete a specific memory by its ID. Get IDs from memory_search or memory_list results. " +
+            "This permanently removes the memory from your semantic store.",
         inputSchema: {
             type: "object",
             properties: {
-                source: {
-                    type: "string",
-                    enum: ["url", "github", "notion", "manual"],
-                    description: "Source type",
-                },
-                url: {
-                    type: "string",
-                    description: "URL to fetch and index (required for url/github/notion sources)",
-                },
-                content: {
-                    type: "string",
-                    description: "Direct content (for source: manual)",
-                },
-                title: { type: "string", description: "Title for this memory" },
+                id: { type: "string", description: "Memory ID to delete (from memory_search or memory_list results)" },
             },
-            required: ["source"],
+            required: ["id"],
+        },
+    },
+    {
+        name: "memory_insight",
+        description: "Get a full intelligence report on any topic — combines semantic memory AND vault entries, " +
+            "then identifies knowledge gaps and suggests next actions. " +
+            "Use this before starting any research or trade decision to see everything Noelclaw already knows. " +
+            "Returns: confidence level, what you know, coverage timeline, gaps, and recommended next steps.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                topic: { type: "string", description: "Topic to analyze — token, protocol, strategy, or any concept" },
+                depth: { type: "string", enum: ["quick", "standard", "deep"], description: "How many sources to pull (default: standard)" },
+            },
+            required: ["topic"],
         },
     },
 ];
@@ -157,42 +139,40 @@ const ContextSchema = zod_1.z.object({
     topic: zod_1.z.string().min(1),
     limit: zod_1.z.number().optional(),
 });
-const ConnectSchema = zod_1.z.object({
-    source: zod_1.z.enum(["url", "github", "notion", "manual"]),
-    url: zod_1.z.string().url().optional(),
-    content: zod_1.z.string().optional(),
-    title: zod_1.z.string().optional(),
+const ListSchema = zod_1.z.object({
+    limit: zod_1.z.number().optional(),
+    tag: zod_1.z.string().optional(),
+});
+const DeleteMemSchema = zod_1.z.object({ id: zod_1.z.string().min(1) });
+const InsightSchema = zod_1.z.object({
+    topic: zod_1.z.string().min(1),
+    depth: zod_1.z.enum(["quick", "standard", "deep"]).optional(),
 });
 // ─── Handler ─────────────────────────────────────────────────────────────────
 async function handleMemoryTool(name, args) {
-    const apiKey = process.env.SUPERMEMORY_API_KEY;
     switch (name) {
         case "memory_add": {
             const parsed = AddSchema.safeParse(args);
             if (!parsed.success)
                 return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
-            if (!apiKey)
-                return { content: [{ type: "text", text: "⚠️ SUPERMEMORY_API_KEY not configured.\nSet it in your MCP env to enable semantic memory.\nGet a free key at supermemory.ai" }], isError: true };
             const { content, title, tags, sourceUrl } = parsed.data;
-            const { ok, data, error } = await smFetch("/memories", "POST", {
+            const data = await (0, convex_js_1.callConvex)("/memory/add", "POST", {
                 content,
-                metadata: { title, tags, source: "noelclaw-mcp", addedAt: Date.now() },
-                spaces: [exports.SM_SPACE],
+                metadata: { title, tags, source: "memory_add", addedAt: Date.now() },
                 ...(sourceUrl ? { sourceUrl } : {}),
-            });
-            if (!ok)
-                return { content: [{ type: "text", text: `Error adding to memory: ${error}` }], isError: true };
-            const memId = data?.id ?? data?.memoryId ?? "saved";
+            }).catch((err) => ({ error: err.message }));
+            if (data?.error)
+                return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
             return {
                 content: [{
                         type: "text",
                         text: [
-                            `🧠 **Memory added** — ID: \`${memId}\``,
+                            `🧠 **Memory added** — ID: \`${data?.id ?? "saved"}\``,
                             title ? `Title: ${title}` : "",
-                            sourceUrl ? `Source: ${sourceUrl}` : "",
+                            sourceUrl ? `Source: ${sourceUrl} (indexing in background…)` : "",
                             tags?.length ? `Tags: ${tags.join(", ")}` : "",
                             ``,
-                            `Find it later with: \`memory_search query: "${(title ?? content).slice(0, 40)}"\``,
+                            `Find it with: \`memory_search query: "${(title ?? content).slice(0, 40)}"\``,
                         ].filter(Boolean).join("\n"),
                     }],
             };
@@ -201,8 +181,6 @@ async function handleMemoryTool(name, args) {
             const parsed = SearchSchema.safeParse(args);
             if (!parsed.success)
                 return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
-            if (!apiKey)
-                return { content: [{ type: "text", text: "⚠️ SUPERMEMORY_API_KEY not configured. Set it in your MCP env to enable semantic memory." }], isError: true };
             const { query, limit = 10 } = parsed.data;
             const results = await searchSupermemory(query, limit);
             if (!results.length)
@@ -223,12 +201,10 @@ async function handleMemoryTool(name, args) {
             const parsed = ContextSchema.safeParse(args);
             if (!parsed.success)
                 return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
-            if (!apiKey)
-                return { content: [{ type: "text", text: "⚠️ SUPERMEMORY_API_KEY not configured. Set it in your MCP env to enable semantic memory." }], isError: true };
             const { topic, limit = 8 } = parsed.data;
             const results = await searchSupermemory(topic, limit);
             if (!results.length)
-                return { content: [{ type: "text", text: `No semantic context found for: "${topic}"\nBuild your memory base with vault_save, vault_remember, or memory_add.` }] };
+                return { content: [{ type: "text", text: `No semantic context found for: "${topic}"\nBuild your memory base with vault_save or memory_add.` }] };
             const contextParts = results.map((r, i) => {
                 const title = r.metadata?.title ? `### ${r.metadata.title}` : `### Memory ${i + 1}`;
                 return `${title}\n${r.content}`;
@@ -249,89 +225,141 @@ async function handleMemoryTool(name, args) {
             };
         }
         case "memory_profile": {
-            if (!apiKey)
-                return { content: [{ type: "text", text: "⚠️ SUPERMEMORY_API_KEY not configured.\n\nSet `SUPERMEMORY_API_KEY` in your MCP env vars.\nGet a free key at supermemory.ai" }], isError: true };
-            const { ok, data, error } = await smFetch(`/memories?spaces=${exports.SM_SPACE}&limit=1`, "GET");
-            if (!ok)
-                return { content: [{ type: "text", text: `Error fetching profile: ${error}` }], isError: true };
-            const count = data?.total ?? data?.count ?? "unknown";
+            const data = await (0, convex_js_1.callConvex)("/memory/profile", "GET").catch(() => null);
+            const total = data?.total ?? 0;
+            const status = data?.status ?? "unknown";
+            const space = data?.space ?? "—";
             return {
                 content: [{
                         type: "text",
                         text: [
-                            `🧠 **Noelclaw Semantic Memory Profile**`,
+                            `🧠 **Noelclaw Semantic Memory**`,
                             ``,
-                            `Space: \`${exports.SM_SPACE}\``,
-                            `Total memories: **${count}**`,
-                            `Status: ✅ Connected (Supermemory)`,
+                            `Space: \`${space}\``,
+                            `Total memories: **${total}**`,
+                            `Status: ${status === "ok" ? "✅ Active" : status === "not_configured" ? "⏳ Setting up" : "⚠️ " + status}`,
                             ``,
-                            `**Data sources:**`,
-                            `• vault_save / vault_remember — auto-synced ✅`,
-                            `• memory_add — direct input ✅`,
-                            `• memory_connect — URL ingestion ✅`,
-                            `• Google Drive / Gmail / Notion — connect via noelclaw.com dashboard`,
+                            `**Auto-synced sources:**`,
+                            `• vault_save — ✅`,
+                            `• memory_add (URL indexing) — ✅`,
+                            `• Google Drive / Gmail / Notion — connect at noelclaw.com`,
                             ``,
-                            `**Capabilities:**`,
-                            `• Semantic search (vector similarity)`,
-                            `• 81.6% LongMemEval accuracy`,
-                            `• Context injection for AI tasks`,
+                            `**Capabilities:** Semantic search · Vector context · 81.6% LongMemEval`,
                         ].join("\n"),
                     }],
             };
         }
-        case "memory_connect": {
-            const parsed = ConnectSchema.safeParse(args);
+        case "memory_list": {
+            const parsed = ListSchema.safeParse(args ?? {});
             if (!parsed.success)
                 return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
-            if (!apiKey)
-                return { content: [{ type: "text", text: "⚠️ SUPERMEMORY_API_KEY not configured. Set it in your MCP env to enable semantic memory." }], isError: true };
-            const { source, url, content, title } = parsed.data;
-            if (source === "manual") {
-                if (!content)
-                    return { content: [{ type: "text", text: "content is required for source: manual" }], isError: true };
-                const { ok, data, error } = await smFetch("/memories", "POST", {
-                    content,
-                    metadata: { title, source: "manual", addedAt: Date.now() },
-                    spaces: [exports.SM_SPACE],
-                });
-                if (!ok)
-                    return { content: [{ type: "text", text: `Error: ${error}` }], isError: true };
-                return { content: [{ type: "text", text: `✅ Memory connected — ID: \`${data?.id ?? "saved"}\`` }] };
+            const { limit = 20, tag } = parsed.data;
+            const data = await (0, convex_js_1.callConvex)("/memory/list", "POST", { n: limit, tag }).catch((err) => ({ error: err.message }));
+            if (data?.error)
+                return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
+            const results = data?.results ?? [];
+            if (!results.length)
+                return { content: [{ type: "text", text: `No memories stored yet. Use \`memory_add\` to start building your knowledge base.` }] };
+            const header = `🧠 **Memories** (${results.length} shown${tag ? `, tag: ${tag}` : ""})`;
+            const rows = results.map((r, i) => {
+                const title = r.metadata?.title ?? "";
+                const preview = r.content.slice(0, 100).replace(/\n/g, " ");
+                return `${i + 1}. \`${r.id}\`${title ? ` **${title}**` : ""}\n   ${preview}${r.content.length > 100 ? "…" : ""}`;
+            });
+            return { content: [{ type: "text", text: [header, "", ...rows].join("\n") }] };
+        }
+        case "memory_delete": {
+            const parsed = DeleteMemSchema.safeParse(args);
+            if (!parsed.success)
+                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+            const data = await (0, convex_js_1.callConvex)("/memory/delete", "POST", { id: parsed.data.id }).catch((err) => ({ error: err.message }));
+            if (data?.error)
+                return { content: [{ type: "text", text: `Error: ${data.error}` }], isError: true };
+            return { content: [{ type: "text", text: `🗑️ Memory deleted: \`${parsed.data.id}\`` }] };
+        }
+        case "memory_insight": {
+            const parsed = InsightSchema.safeParse(args);
+            if (!parsed.success)
+                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+            const { topic, depth = "standard" } = parsed.data;
+            const memLimit = depth === "deep" ? 15 : depth === "quick" ? 5 : 8;
+            // Pull from semantic memory and vault in parallel
+            const [memResults, vaultData] = await Promise.all([
+                searchSupermemory(topic, memLimit),
+                (0, convex_js_1.callConvex)(`/vault/search?q=${encodeURIComponent(topic)}&limit=6`, "GET", undefined, "memory_insight").catch(() => ({ results: [] })),
+            ]);
+            const vaultResults = vaultData.results ?? [];
+            const total = memResults.length + vaultResults.length;
+            if (!total) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: [
+                                `🔮 **Intelligence Report: "${topic}"**`,
+                                ``,
+                                `No knowledge found yet.`,
+                                ``,
+                                `**Start building:**`,
+                                `• \`swarm_research topic: "${topic}"\` — run deep research now`,
+                                `• \`memory_add content: "..." \` — add a manual note`,
+                                `• \`swarm_watch topic: "${topic}"\` — start monitoring`,
+                            ].join("\n"),
+                        }],
+                };
             }
-            if (!url)
-                return { content: [{ type: "text", text: `url is required for source: ${source}` }], isError: true };
-            const { ok, data, error } = await smFetch("/memories", "POST", {
-                content: title ?? "",
-                sourceUrl: url,
-                metadata: { title, source, connectedAt: Date.now() },
-                spaces: [exports.SM_SPACE],
+            // Confidence tier
+            const confidence = total >= 10 ? "🟢 High" : total >= 4 ? "🟡 Medium" : "🔴 Low";
+            // Timeline from metadata timestamps
+            const timestamps = memResults.map(r => r.metadata?.addedAt).filter(Boolean);
+            const oldest = timestamps.length ? Math.min(...timestamps) : null;
+            const newest = timestamps.length ? Math.max(...timestamps) : null;
+            const daysSinceUpdate = newest ? Math.round((Date.now() - newest) / 86400000) : null;
+            // Knowledge summary lines
+            const memLines = memResults.slice(0, 6).map(r => {
+                const title = r.metadata?.title ?? r.content.slice(0, 70).replace(/\n/g, " ");
+                const score = r.score != null ? ` [${(r.score * 100).toFixed(0)}%]` : "";
+                return `  •${score} ${title}`;
             });
-            if (!ok)
-                return { content: [{ type: "text", text: `Error connecting source: ${error}` }], isError: true };
-            const sourceLabels = {
-                url: "Web page",
-                github: "GitHub repo",
-                notion: "Notion page",
-            };
-            return {
-                content: [{
-                        type: "text",
-                        text: [
-                            `✅ **${sourceLabels[source] ?? source} connected**`,
-                            `URL: ${url}`,
-                            `Memory ID: \`${data?.id ?? "queued"}\``,
-                            ``,
-                            `Supermemory is fetching and indexing the content in the background.`,
-                            `Search it in ~30s with: \`memory_search query: "${title ?? url.split("/").pop()}"\``,
-                            ``,
-                            source === "github"
-                                ? `💡 Tip: For full repo sync (all files), connect via the Noelclaw dashboard at noelclaw.com`
-                                : source === "notion"
-                                    ? `💡 Tip: For full Notion workspace sync, connect via the Noelclaw dashboard at noelclaw.com`
-                                    : "",
-                        ].filter(Boolean).join("\n"),
-                    }],
-            };
+            const vaultLines = vaultResults.slice(0, 4).map((r) => `  • [vault/${r.type}] ${r.title} — v${r.version}`);
+            // Gap analysis
+            const gaps = [];
+            if (daysSinceUpdate !== null && daysSinceUpdate > 7) {
+                gaps.push(`Stale data — last update ${daysSinceUpdate} day${daysSinceUpdate !== 1 ? "s" : ""} ago`);
+            }
+            if (!vaultResults.some((r) => r.type === "research")) {
+                gaps.push("No formal research saved — only informal notes exist");
+            }
+            if (memResults.length < 3) {
+                gaps.push("Thin coverage — fewer than 3 semantic memories on this topic");
+            }
+            if (!vaultResults.some((r) => r.type === "execution")) {
+                gaps.push("No execution history — no trades or actions logged");
+            }
+            const lines = [
+                `🔮 **Intelligence Report: "${topic}"**`,
+                `Confidence: ${confidence} · ${memResults.length} semantic memories · ${vaultResults.length} vault entries`,
+                oldest ? `Coverage: ${new Date(oldest).toLocaleDateString("en-US")} – ${daysSinceUpdate === 0 ? "today" : daysSinceUpdate !== null ? `${daysSinceUpdate}d ago` : "unknown"}` : "",
+                ``,
+                `**What you know:**`,
+                ...memLines,
+                ...(vaultLines.length ? ["", "**Vault entries:**", ...vaultLines] : []),
+                ``,
+            ];
+            if (gaps.length) {
+                lines.push(`**⚠️ Knowledge gaps:**`);
+                gaps.forEach(g => lines.push(`  • ${g}`));
+                lines.push("");
+            }
+            lines.push(`**Suggested actions:**`);
+            if (gaps.some(g => g.includes("research") || g.includes("Stale"))) {
+                lines.push(`• \`swarm_research topic: "${topic}"\` — refresh with deep research`);
+            }
+            if (gaps.some(g => g.includes("Stale"))) {
+                lines.push(`• \`trigger_agent agentId: "market-monitor" params: { token: "${topic.split(" ")[0].toUpperCase()}" }\``);
+            }
+            lines.push(`• \`memory_context topic: "${topic}"\` — inject full context into your next prompt`);
+            lines.push(`• \`swarm_watch topic: "${topic}"\` — monitor this topic continuously`);
+            return { content: [{ type: "text", text: lines.filter(l => l !== undefined).join("\n") }] };
         }
         default:
             return null;

package/dist/tools/miroshark.js

@@ -179,6 +179,9 @@ async function handleMirosharkTool(name, args) {
             return { content: [{ type: "text", text: "simulation_id is required" }], isError: true };
         }
         const simId = a.simulation_id.trim();
+        if (!/^[a-zA-Z0-9_-]{5,100}$/.test(simId)) {
+            return { content: [{ type: "text", text: "Invalid simulation_id format." }], isError: true };
+        }
         try {
             // Check run status first
             const runStatus = await miroJson(`/miroshark/api/simulation/${simId}/run-status`, "GET").catch(() => ({ runner_status: "idle" }));
@@ -273,15 +276,20 @@ async function handleMirosharkTool(name, args) {
                         // brief stays empty — non-critical
                     }
                 }
-                // Auto-save to vault if key is available
-                const savedToVault = false;
+                // Auto-save to vault if brief was generated
+                let savedToVault = false;
                 if (brief) {
                     try {
                         await (0, convex_js_1.callConvex)("/vault/save", "POST", {
+                            type: "research",
+                            title: `MiroShark: ${a.scenario?.slice(0, 80) ?? simId}`,
+                            content: brief,
                             key: `miroshark-${simId.slice(0, 8)}`,
-                            value: brief,
+                            agentId: "miroshark",
                             tags: ["miroshark", "simulation", "research"],
+                            commitMsg: "miroshark auto-save",
                         }, "vault_save");
+                        savedToVault = true;
                     }
                     catch {
                         // non-critical
@@ -299,7 +307,7 @@ async function handleMirosharkTool(name, args) {
                     lines.push(`**Agent Feed** (${Math.min(actions.length, 20)} of ${totalActions}):`);
                     lines.push(...feed);
                 }
-                if (brief) {
+                if (savedToVault) {
                     lines.push("", `_Findings auto-saved to vault as \`miroshark-${simId.slice(0, 8)}\`_`);
                 }
                 return { content: [{ type: "text", text: lines.join("\n") }] };
@@ -326,6 +334,9 @@ async function handleMirosharkTool(name, args) {
             return { content: [{ type: "text", text: "simulation_id is required" }], isError: true };
         }
         const simId = a.simulation_id.trim();
+        if (!/^[a-zA-Z0-9_-]{5,100}$/.test(simId)) {
+            return { content: [{ type: "text", text: "Invalid simulation_id format." }], isError: true };
+        }
         try {
             await miroJson(`/miroshark/api/simulation/${simId}/stop`, "POST", {});
             return { content: [{ type: "text", text: `⏹️ Simulation \`${simId}\` stopped.` }] };