@noelclaw/mcp 2.3.1 → 3.0.0

package/dist/tools/memory.js

@@ -29,16 +29,17 @@ exports.MEMORY_TOOLS = [
         name: "memory_add",
         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, URLs, or anything you want to find later " +
-            "with natural language. Memory is indexed semantically — 'what did I say about ETH yield?' " +
+            "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 — Noelclaw will fetch and index the page content automatically" },
+                sourceUrl: { type: "string", description: "URL to fetch and index automatically (GitHub, Notion, web page, etc.). Content becomes searchable in ~30s." },
             },
             required: ["content"],
         },
@@ -47,7 +48,7 @@ exports.MEMORY_TOOLS = [
         name: "memory_search",
         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 and vault_remember.",
+            "Also searches memories auto-synced from vault_save.",
         inputSchema: {
             type: "object",
             properties: {
@@ -61,7 +62,7 @@ exports.MEMORY_TOOLS = [
         name: "memory_context",
         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. " +
-            "Smarter than vault_context — uses vector search, not just keyword matching.",
+            "Uses vector search — finds semantically related content, not just exact keyword matches.",
         inputSchema: {
             type: "object",
             properties: {
@@ -82,19 +83,44 @@ exports.MEMORY_TOOLS = [
         },
     },
     {
-        name: "memory_connect",
-        description: "Fetch and index content from an external URL into your semantic memory. " +
-            "Works with any web page, GitHub repo/file, or Notion page URL. " +
-            "Noelclaw crawls the URL and indexes the full content — searchable in ~30s. " +
-            "For full Google Drive / Gmail / Notion workspace sync, connect via the 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: {
-                url: { type: "string", description: "URL to fetch and index (GitHub, Notion, web page, etc.)" },
-                title: { type: "string", description: "Optional title for this memory" },
-                tags: { type: "array", items: { type: "string" }, description: "Optional tags" },
+                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: {
+                id: { type: "string", description: "Memory ID to delete (from memory_search or memory_list results)" },
+            },
+            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: ["url"],
+            required: ["topic"],
         },
     },
 ];
@@ -113,10 +139,14 @@ 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({
-    url: zod_1.z.string().url(),
-    title: zod_1.z.string().optional(),
-    tags: zod_1.z.array(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) {
@@ -174,7 +204,7 @@ async function handleMemoryTool(name, args) {
             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}`;
@@ -210,8 +240,8 @@ async function handleMemoryTool(name, args) {
                             `Status: ${status === "ok" ? "✅ Active" : status === "not_configured" ? "⏳ Setting up" : "⚠️ " + status}`,
                             ``,
                             `**Auto-synced sources:**`,
-                            `• vault_save + vault_remember — ✅`,
-                            `• memory_add + memory_connect — ✅`,
+                            `• vault_save — ✅`,
+                            `• memory_add (URL indexing) — ✅`,
                             `• Google Drive / Gmail / Notion — connect at noelclaw.com`,
                             ``,
                             `**Capabilities:** Semantic search · Vector context · 81.6% LongMemEval`,
@@ -219,31 +249,117 @@ async function handleMemoryTool(name, args) {
                     }],
             };
         }
-        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 };
-            const { url, title, tags } = parsed.data;
-            const inferredTitle = title ?? url.split("/").filter(Boolean).pop() ?? url;
-            const data = await (0, convex_js_1.callConvex)("/memory/add", "POST", {
-                content: inferredTitle,
-                sourceUrl: url,
-                metadata: { title: inferredTitle, tags, source: "memory_connect", connectedAt: Date.now() },
-            }).catch((err) => ({ error: err.message }));
+            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 };
-            return {
-                content: [{
-                        type: "text",
-                        text: [
-                            `✅ **Connected**: ${url}`,
-                            `Memory ID: \`${data?.id ?? "queued"}\``,
-                            ``,
-                            `Noelclaw is fetching and indexing the content in the background.`,
-                            `Search it in ~30s: \`memory_search query: "${inferredTitle.slice(0, 40)}"\``,
-                        ].join("\n"),
-                    }],
-            };
+            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"),
+                        }],
+                };
+            }
+            // 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}`;
+            });
+            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.` }] };

package/dist/tools/os.js

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OS_TOOLS = void 0;
+exports.handleOsTool = handleOsTool;
+const zod_1 = require("zod");
+const convex_js_1 = require("../convex.js");
+const market_js_1 = require("./market.js");
+const memory_js_1 = require("./memory.js");
+exports.OS_TOOLS = [
+    {
+        name: "noel_status",
+        description: "Full system dashboard for the Noelclaw AI OS — memory usage, swarm health, active automations, " +
+            "recent vault research, and execution scores. Like `htop` but for your AI operating system. " +
+            "Run this to get a complete picture of what's running and what your OS currently knows.",
+        inputSchema: { type: "object", properties: {}, required: [] },
+    },
+    {
+        name: "noel_boot",
+        description: "Boot sequence for the Noelclaw AI OS — starts the swarm, loads live market prices, checks active automations, " +
+            "and returns a unified briefing. One command to wake up the entire operating system. " +
+            "Run this first to prime the system before any trading or research session.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                focus: {
+                    type: "string",
+                    description: "Optional: token or topic to focus today's session on (e.g. 'ETH', 'Base ecosystem')",
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: "noel_shutdown",
+        description: "Clean shutdown of the Noelclaw AI OS — stops the swarm, saves a session summary to vault, and returns a final briefing. " +
+            "Run at the end of a trading or research session to persist all findings before signing off.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                note: {
+                    type: "string",
+                    description: "Optional: a note to save with the session summary (e.g. 'Closed ETH position, watching BTC')",
+                },
+            },
+            required: [],
+        },
+    },
+];
+const BootSchema = zod_1.z.object({ focus: zod_1.z.string().optional() });
+const ShutdownSchema = zod_1.z.object({ note: zod_1.z.string().max(500).optional() });
+async function handleOsTool(name, args) {
+    switch (name) {
+        case "noel_status": {
+            const [memRes, swarmRes, autoRes, vaultRes, scoresRes] = await Promise.allSettled([
+                (0, convex_js_1.callConvex)("/memory/profile", "GET"),
+                (0, convex_js_1.callConvex)("/swarm/status", "GET", undefined, "get_swarm_status"),
+                (0, convex_js_1.callConvex)("/automations/list", "GET", undefined, "list_automations"),
+                (0, convex_js_1.callConvex)("/vault/list?type=research&limit=5", "GET", undefined, "noel_status"),
+                (0, convex_js_1.callConvex)("/swarm/scores", "GET", undefined, "get_execution_scores"),
+            ]);
+            const mem = memRes.status === "fulfilled" ? memRes.value : null;
+            const swarm = swarmRes.status === "fulfilled" ? swarmRes.value : null;
+            const autos = autoRes.status === "fulfilled" ? autoRes.value : null;
+            const vault = vaultRes.status === "fulfilled" ? vaultRes.value : null;
+            const scores = scoresRes.status === "fulfilled" ? scoresRes.value : null;
+            const automations = autos?.automations ?? [];
+            const activeAutos = automations.filter((a) => a.status === "active");
+            const vaultEntries = vault?.entries ?? [];
+            const allScores = (scores?.scores ?? []).sort((a, b) => b.lastScore - a.lastScore);
+            const topScore = allScores[0];
+            const swarmActive = swarm?.active ?? false;
+            const memTotal = mem?.total ?? 0;
+            const memStatus = mem?.status ?? "unknown";
+            const lines = [
+                `**Noelclaw AI OS — System Status**`,
+                `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`,
+                ``,
+                `🧠 **Memory**       ${memStatus === "ok" ? "✅" : "⚠️"} ${memTotal} memories · Space: ${mem?.space ?? "—"}`,
+                `🤖 **Swarm**        ${swarmActive ? "✅ Active" : "⏹️ Offline"} · ${swarm?.memory?.length ?? 0} shared memory entries`,
+                `⚡ **Automations**  ${activeAutos.length} active of ${automations.length} total`,
+                allScores.length
+                    ? `📊 **Top Skill**    ${topScore.skillName} — ${((topScore.lastScore ?? 0) * 100).toFixed(0)}% · ${topScore.successCount}W/${topScore.failCount}L`
+                    : `📊 **Skills**       No execution history yet`,
+                ``,
+            ];
+            if (activeAutos.length > 0) {
+                lines.push(`**Active Automations:**`);
+                for (const a of activeAutos.slice(0, 5)) {
+                    const next = a.nextRunAt ? ` · next ${new Date(a.nextRunAt).toUTCString()}` : "";
+                    lines.push(`  • ${a.name} — ${a.triggerType}${next}`);
+                }
+                lines.push("");
+            }
+            if (vaultEntries.length > 0) {
+                lines.push(`**Recent Research:**`);
+                for (const e of vaultEntries) {
+                    lines.push(`  • [${e.agentId ?? "vault"}] ${e.title}`);
+                }
+                lines.push("");
+            }
+            lines.push(swarmActive
+                ? `💡 Run \`swarm_pulse\` for a live snapshot from all agents.`
+                : `💡 Run \`noel_boot\` to wake up the full system.`);
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+        case "noel_boot": {
+            const parsed = BootSchema.safeParse(args ?? {});
+            if (!parsed.success)
+                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+            const { focus } = parsed.data;
+            const [swarmRes, marketRes, autoRes, memRes, focusRes] = await Promise.allSettled([
+                (0, convex_js_1.callConvex)("/swarm/start", "POST", {}, "start_swarm"),
+                (0, market_js_1.fetchMarketSnapshot)(),
+                (0, convex_js_1.callConvex)("/automations/list", "GET", undefined, "list_automations"),
+                (0, convex_js_1.callConvex)("/memory/profile", "GET"),
+                focus ? (0, memory_js_1.searchSupermemory)(focus, 4) : Promise.resolve([]),
+            ]);
+            const swarm = swarmRes.status === "fulfilled" ? swarmRes.value : null;
+            const market = marketRes.status === "fulfilled" ? marketRes.value : null;
+            const autos = autoRes.status === "fulfilled" ? autoRes.value : null;
+            const mem = memRes.status === "fulfilled" ? memRes.value : null;
+            const focusMem = focusRes.status === "fulfilled" ? focusRes.value : [];
+            const automations = autos?.automations ?? [];
+            const activeAutos = automations.filter((a) => a.status === "active");
+            const memTotal = mem?.total ?? 0;
+            const p = (n) => `$${n.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
+            const lines = [
+                `🚀 **Noelclaw AI OS — Boot Complete**`,
+                `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`,
+                `${new Date().toUTCString()}`,
+                ``,
+                `**Subsystems:**`,
+                `  🤖 Swarm        ${swarm?.success ? `✅ Online · session ${swarm.sessionId ?? "active"}` : "⚠️ Could not start"}`,
+                `  🧠 Memory       ✅ ${memTotal} memories ready`,
+                `  ⚡ Automations  ${activeAutos.length} active of ${automations.length}`,
+                ``,
+            ];
+            if (market) {
+                lines.push(`**Market Snapshot:**`);
+                lines.push(`  BTC ${p(market.btc)}  ·  ETH ${p(market.eth)}  ·  SOL ${p(market.sol)}`);
+                lines.push("");
+            }
+            if (activeAutos.length > 0) {
+                lines.push(`**Active Automations:**`);
+                for (const a of activeAutos.slice(0, 5)) {
+                    const next = a.nextRunAt ? ` · runs ${new Date(a.nextRunAt).toUTCString()}` : "";
+                    lines.push(`  • ${a.name}${next}`);
+                }
+                lines.push("");
+            }
+            if (focus && focusMem.length > 0) {
+                lines.push(`**Memory context for "${focus}" (${focusMem.length} items):**`);
+                for (const r of focusMem) {
+                    const title = r.metadata?.title ?? r.content.slice(0, 70).replace(/\n/g, " ");
+                    lines.push(`  • ${title}`);
+                }
+                lines.push("");
+            }
+            lines.push(`**Quick actions:**`);
+            lines.push(`  • \`swarm_pulse\` — live readings from all agents`);
+            if (focus) {
+                lines.push(`  • \`swarm_research topic: "${focus}"\` — deep research session`);
+                lines.push(`  • \`memory_insight topic: "${focus}"\` — full intelligence report`);
+            }
+            else {
+                lines.push(`  • \`swarm_research topic: "BTC"\` — start morning research`);
+                lines.push(`  • \`noel_status\` — full system dashboard`);
+            }
+            return { content: [{ type: "text", text: lines.join("\n") }] };
+        }
+        case "noel_shutdown": {
+            const parsed = ShutdownSchema.safeParse(args ?? {});
+            if (!parsed.success)
+                return { content: [{ type: "text", text: `Invalid input: ${parsed.error.issues[0].message}` }], isError: true };
+            const { note } = parsed.data;
+            const [swarmRes, vaultRes] = await Promise.allSettled([
+                (0, convex_js_1.callConvex)("/swarm/stop", "POST", {}, "stop_swarm"),
+                (0, convex_js_1.callConvex)("/vault/list?type=research&limit=5", "GET", undefined, "noel_shutdown"),
+            ]);
+            const swarm = swarmRes.status === "fulfilled" ? swarmRes.value : null;
+            const vault = vaultRes.status === "fulfilled" ? vaultRes.value : null;
+            const vaultEntries = vault?.entries ?? [];
+            const now = new Date();
+            const sessionKey = `session/shutdown-${now.toISOString().slice(0, 10)}-${now.getHours()}h`;
+            const summaryContent = [
+                `# Session Shutdown — ${now.toUTCString()}`,
+                note ? `\nNote: ${note}` : "",
+                `\n## Recent Research`,
+                ...vaultEntries.map((e) => `• [${e.agentId ?? "vault"}] ${e.title}`),
+            ].filter(Boolean).join("\n");
+            await (0, convex_js_1.callConvex)("/vault/save", "POST", {
+                type: "memory",
+                title: `Session: ${now.toLocaleDateString("en-US")}${note ? ` — ${note.slice(0, 50)}` : ""}`,
+                content: summaryContent,
+                key: sessionKey,
+                agentId: "os",
+                tags: ["session", "shutdown"],
+                commitMsg: "noel_shutdown session save",
+            }, "noel_shutdown").catch(() => { });
+            const lines = [
+                `⏹️ **Noelclaw AI OS — Shutdown**`,
+                `━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`,
+                `${now.toUTCString()}`,
+                ``,
+                `🤖 Swarm      ${swarm?.success ? "✅ Stopped" : "⚠️ Already offline"}`,
+                `💾 Session    ✅ Saved to vault: \`${sessionKey}\``,
+                note ? `📝 Note       ${note}` : "",
+                ``,
+            ];
+            if (vaultEntries.length > 0) {
+                lines.push(`**Session research (${vaultEntries.length} entries):**`);
+                for (const e of vaultEntries) {
+                    lines.push(`  • [${e.agentId ?? "vault"}] ${e.title}`);
+                }
+                lines.push("");
+            }
+            lines.push(`Run \`noel_boot\` to start a new session.`);
+            return { content: [{ type: "text", text: lines.filter(l => l !== undefined && l !== "").join("\n") }] };
+        }
+        default:
+            return null;
+    }
+}