@getmarrow/mcp 2.7.0 → 2.9.0

package/dist/cli.js

@@ -20,13 +20,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 const readline = __importStar(require("readline"));
 const index_1 = require("./index");
@@ -40,6 +50,26 @@ if (!API_KEY) {
 // Auto-orient on startup — cache warnings, inject into EVERY marrow_think response
 let cachedOrientWarnings = [];
 let thinkCallCount = 0;
+const pendingDecisions = new Map();
+const PENDING_TTL_MS = 30 * 60 * 1000; // 30 min TTL
+function actionHash(action) {
+    const normalized = action.toLowerCase().trim().replace(/\s+/g, ' ');
+    // djb2 hash to prevent decision_id mismatches from normalization-only collisions
+    let h = 5381;
+    for (let i = 0; i < normalized.length; i++) {
+        h = ((h << 5) + h) ^ normalized.charCodeAt(i);
+        h = h >>> 0;
+    }
+    return h.toString(36) + '_' + normalized.slice(0, 32);
+}
+function cleanupPending() {
+    const now = Date.now();
+    for (const [key, val] of pendingDecisions) {
+        if (now - val.timestamp > PENDING_TTL_MS) {
+            pendingDecisions.delete(key);
+        }
+    }
+}
 function formatWarningActionably(w) {
     const pct = Math.round(w.failureRate * 100);
     return `⚠️ ${w.type} has ${pct}% failure rate — check what went wrong last time before proceeding`;
@@ -49,11 +79,13 @@ async function refreshOrientWarnings() {
         const r = await (0, index_1.marrowOrient)(API_KEY, BASE_URL, undefined, SESSION_ID);
         cachedOrientWarnings = r.warnings;
     }
-    catch { }
+    catch {
+        // ignore
+    }
 }
 // Initial orient
 refreshOrientWarnings().then(() => {
-    if (cachedOrientWarnings.some(w => w.failureRate > 0.4)) {
+    if (cachedOrientWarnings.some((w) => w.failureRate > 0.4)) {
         process.stderr.write(`[marrow] ⚠️ High failure rate detected on startup — call marrow_orient for details before acting\n`);
     }
 });
@@ -72,7 +104,9 @@ async function autoCommitOnClose() {
             }, SESSION_ID);
             clearTimeout(timeout);
         }
-        catch { }
+        catch {
+            // ignore
+        }
     }
 }
 process.on('SIGTERM', async () => {
@@ -81,7 +115,9 @@ process.on('SIGTERM', async () => {
     await autoCommitOnClose();
     process.exit(0);
 });
-process.stdin.on('end', async () => { await autoCommitOnClose(); });
+process.stdin.on('end', async () => {
+    await autoCommitOnClose();
+});
 function send(response) {
     process.stdout.write(JSON.stringify(response) + '\n');
 }
@@ -91,6 +127,157 @@ function success(id, result) {
 function error(id, code, message) {
     send({ jsonrpc: '2.0', id, error: { code, message } });
 }
+// Memory API functions
+async function marrowListMemories(apiKey, baseUrl, params, sessionId) {
+    const qs = new URLSearchParams();
+    if (params?.status)
+        qs.set('status', params.status);
+    if (params?.query)
+        qs.set('query', params.query);
+    if (params?.limit)
+        qs.set('limit', String(params.limit));
+    if (params?.agentId)
+        qs.set('agent_id', params.agentId);
+    const res = await fetch(`${baseUrl}/v1/memories?${qs.toString()}`, {
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            ...(sessionId ? { 'X-Marrow-Session-Id': sessionId } : {}),
+        },
+    });
+    const json = await res.json();
+    return json.data?.memories || [];
+}
+async function marrowGetMemory(apiKey, baseUrl, id, sessionId) {
+    const res = await fetch(`${baseUrl}/v1/memories/${id}`, {
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            ...(sessionId ? { 'X-Marrow-Session-Id': sessionId } : {}),
+        },
+    });
+    const json = await res.json();
+    return json.data?.memory || null;
+}
+async function marrowUpdateMemory(apiKey, baseUrl, id, patch, sessionId) {
+    const res = await fetch(`${baseUrl}/v1/memories/${id}`, {
+        method: 'PATCH',
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            'Content-Type': 'application/json',
+            ...(sessionId ? { 'X-Marrow-Session-Id': sessionId } : {}),
+        },
+        body: JSON.stringify(patch),
+    });
+    const json = await res.json();
+    return json.data.memory;
+}
+async function marrowDeleteMemory(apiKey, baseUrl, id, meta, sessionId) {
+    const res = await fetch(`${baseUrl}/v1/memories/${id}`, {
+        method: 'DELETE',
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            'Content-Type': 'application/json',
+            ...(sessionId ? { 'X-Marrow-Session-Id': sessionId } : {}),
+        },
+        body: JSON.stringify(meta || {}),
+    });
+    const json = await res.json();
+    return json.data.memory;
+}
+async function marrowMarkOutdated(apiKey, baseUrl, id, meta, sessionId) {
+    const res = await fetch(`${baseUrl}/v1/memories/${id}/outdated`, {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            'Content-Type': 'application/json',
+            ...(sessionId ? { 'X-Marrow-Session-Id': sessionId } : {}),
+        },
+        body: JSON.stringify(meta || {}),
+    });
+    const json = await res.json();
+    return json.data.memory;
+}
+async function marrowSupersedeMemory(apiKey, baseUrl, id, replacement, sessionId) {
+    const res = await fetch(`${baseUrl}/v1/memories/${id}/supersede`, {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            'Content-Type': 'application/json',
+            ...(sessionId ? { 'X-Marrow-Session-Id': sessionId } : {}),
+        },
+        body: JSON.stringify(replacement),
+    });
+    const json = await res.json();
+    return json.data;
+}
+async function marrowShareMemory(apiKey, baseUrl, id, agentIds, actor, sessionId) {
+    const res = await fetch(`${baseUrl}/v1/memories/${id}/share`, {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            'Content-Type': 'application/json',
+            ...(sessionId ? { 'X-Marrow-Session-Id': sessionId } : {}),
+        },
+        body: JSON.stringify({ agent_ids: agentIds, actor }),
+    });
+    const json = await res.json();
+    return json.data.memory;
+}
+async function marrowExportMemories(apiKey, baseUrl, params, sessionId) {
+    const qs = new URLSearchParams();
+    if (params?.format)
+        qs.set('format', params.format);
+    if (params?.status)
+        qs.set('status', params.status);
+    if (params?.tags)
+        qs.set('tags', params.tags);
+    const res = await fetch(`${baseUrl}/v1/memories/export?${qs.toString()}`, {
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            ...(sessionId ? { 'X-Marrow-Session-Id': sessionId } : {}),
+        },
+    });
+    const json = await res.json();
+    return json.data;
+}
+async function marrowImportMemories(apiKey, baseUrl, memories, mode, sessionId) {
+    const res = await fetch(`${baseUrl}/v1/memories/import`, {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            'Content-Type': 'application/json',
+            ...(sessionId ? { 'X-Marrow-Session-Id': sessionId } : {}),
+        },
+        body: JSON.stringify({ memories, mode }),
+    });
+    const json = await res.json();
+    return json.data;
+}
+async function marrowRetrieveMemories(apiKey, baseUrl, query, params, sessionId) {
+    const qs = new URLSearchParams();
+    qs.set('q', query);
+    if (params?.limit)
+        qs.set('limit', String(params.limit));
+    if (params?.from)
+        qs.set('from', params.from);
+    if (params?.to)
+        qs.set('to', params.to);
+    if (params?.tags)
+        qs.set('tags', params.tags);
+    if (params?.source)
+        qs.set('source', params.source);
+    if (params?.status)
+        qs.set('status', params.status);
+    if (params?.shared !== undefined)
+        qs.set('shared', String(params.shared));
+    const res = await fetch(`${baseUrl}/v1/memories/retrieve?${qs.toString()}`, {
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            ...(sessionId ? { 'X-Marrow-Session-Id': sessionId } : {}),
+        },
+    });
+    const json = await res.json();
+    return json.data;
+}
 // Tool definitions
 const TOOLS = [
     {
@@ -205,6 +392,36 @@ const TOOLS = [
             required: ['description', 'success', 'outcome'],
         },
     },
+    {
+        name: 'marrow_auto',
+        description: 'Zero-friction Marrow logging. One call for any action — Marrow handles everything in the background without blocking. ' +
+            'Pass what you are about to do. Optionally pass outcome if already done. ' +
+            'Use for ANY action: deploys, file writes, API calls, external sends. ' +
+            'If you only have time for one call: pass action + outcome + success together — done in one shot.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                action: {
+                    type: 'string',
+                    description: 'What you are about to do or just did',
+                },
+                outcome: {
+                    type: 'string',
+                    description: 'What happened (if already done). Omit to log intent only.',
+                },
+                success: {
+                    type: 'boolean',
+                    description: 'Did it succeed (default: true)',
+                },
+                type: {
+                    type: 'string',
+                    enum: ['implementation', 'security', 'architecture', 'process', 'general'],
+                    description: 'Type of action (default: general)',
+                },
+            },
+            required: ['action'],
+        },
+    },
     {
         name: 'marrow_ask',
         description: 'Query the collective hive in plain English. ' +
@@ -230,6 +447,145 @@ const TOOLS = [
             required: [],
         },
     },
+    {
+        name: 'marrow_list_memories',
+        description: 'List memories with optional filters (status, query, limit, agent_id for shared memories).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                status: { type: 'string', enum: ['active', 'outdated', 'deleted'], description: 'Filter by status' },
+                query: { type: 'string', description: 'Search query' },
+                limit: { type: 'number', description: 'Max results (default: 20)' },
+                agentId: { type: 'string', description: 'Agent ID for shared memories' },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'marrow_get_memory',
+        description: 'Get a single memory by ID.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'Memory ID' },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'marrow_update_memory',
+        description: 'Update memory text, tags, or metadata.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'Memory ID' },
+                text: { type: 'string', description: 'New text' },
+                source: { type: 'string', description: 'Source' },
+                tags: { type: 'array', items: { type: 'string' }, description: 'Tags' },
+                actor: { type: 'string', description: 'Actor name' },
+                note: { type: 'string', description: 'Audit note' },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'marrow_delete_memory',
+        description: 'Soft delete a memory.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'Memory ID' },
+                actor: { type: 'string', description: 'Actor name' },
+                note: { type: 'string', description: 'Audit note' },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'marrow_mark_outdated',
+        description: 'Mark a memory as outdated.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'Memory ID' },
+                actor: { type: 'string', description: 'Actor name' },
+                note: { type: 'string', description: 'Audit note' },
+            },
+            required: ['id'],
+        },
+    },
+    {
+        name: 'marrow_supersede_memory',
+        description: 'Atomically replace a memory with a new version.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'Memory ID to supersede' },
+                text: { type: 'string', description: 'New memory text' },
+                source: { type: 'string', description: 'Source' },
+                tags: { type: 'array', items: { type: 'string' }, description: 'Tags' },
+                actor: { type: 'string', description: 'Actor name' },
+                note: { type: 'string', description: 'Audit note' },
+            },
+            required: ['id', 'text'],
+        },
+    },
+    {
+        name: 'marrow_share_memory',
+        description: 'Share a memory with specific agents.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                id: { type: 'string', description: 'Memory ID' },
+                agentIds: { type: 'array', items: { type: 'string' }, description: 'Agent IDs to share with' },
+                actor: { type: 'string', description: 'Actor name' },
+            },
+            required: ['id', 'agentIds'],
+        },
+    },
+    {
+        name: 'marrow_export_memories',
+        description: 'Export memories to JSON or CSV.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                format: { type: 'string', enum: ['json', 'csv'], description: 'Export format' },
+                status: { type: 'string', enum: ['active', 'all'], description: 'Filter by status' },
+                tags: { type: 'string', description: 'Comma-separated tags' },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'marrow_import_memories',
+        description: 'Import memories with merge (dedup) or replace mode.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                memories: { type: 'array', items: { type: 'object', properties: { text: { type: 'string' }, source: { type: 'string' }, tags: { type: 'array', items: { type: 'string' } } } }, description: 'Memories to import' },
+                mode: { type: 'string', enum: ['merge', 'replace'], description: 'Import mode' },
+            },
+            required: ['memories', 'mode'],
+        },
+    },
+    {
+        name: 'marrow_retrieve_memories',
+        description: 'Full-text search memories with filters (from, to, tags, source, status, shared).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Search query' },
+                limit: { type: 'number', description: 'Max results' },
+                from: { type: 'string', description: 'From date (ISO-8601)' },
+                to: { type: 'string', description: 'To date (ISO-8601)' },
+                tags: { type: 'string', description: 'Comma-separated tags' },
+                source: { type: 'string', description: 'Source filter' },
+                status: { type: 'string', enum: ['active', 'outdated', 'deleted'], description: 'Status filter' },
+                shared: { type: 'boolean', description: 'Include shared memories' },
+            },
+            required: ['query'],
+        },
+    },
 ];
 // Request handler
 async function handleRequest(req) {
@@ -239,7 +595,7 @@ async function handleRequest(req) {
             success(id, {
                 protocolVersion: '2024-11-05',
                 capabilities: { tools: {}, prompts: {} },
-                serverInfo: { name: 'marrow', version: '2.7.0' },
+                serverInfo: { name: 'marrow', version: '2.8.0' },
             });
             return;
         }
@@ -249,9 +605,9 @@ async function handleRequest(req) {
                     {
                         name: 'marrow-always-on',
                         description: 'Always-on Marrow memory loop. Instructs the agent to orient at session start, log intent before meaningful actions, and commit outcomes after completion. Install once — works automatically.',
-                        arguments: []
-                    }
-                ]
+                        arguments: [],
+                    },
+                ],
             });
             return;
         }
@@ -270,25 +626,19 @@ async function handleRequest(req) {
                             type: 'text',
                             text: `You have Marrow — a memory layer that tells you what went wrong last time before you do it again.
 
-## MANDATORY: Call Marrow before every meaningful action
+## PRIMARY: Use marrow_auto for everything
 
-Before exec, write, deploy, publish, send, delete — call marrow_think. No exceptions.
-Marrow returns what broke last time, what worked, and what to watch for. Follow the recommendedNext field.
+One tool. Two calls max. Zero loop management.
 
-## Default: Use marrow_run for 90% of cases
+The minimum loop:
+1. Before any external action: \`marrow_auto({ action: "...what you are about to do" })\`
+2. After the action: \`marrow_auto({ action: "...", outcome: "...what happened", success: true/false })\`
 
-One call. Done. No loop management.
-- description: what you did
-- success: true or false
-- outcome: one line of what happened
+If you only have time for one call: \`marrow_auto({ action: "did X", outcome: "result", success: true })\` — that's the whole loop.
 
-marrow_run handles orient → think → commit in a single call. Use it unless you need fine-grained control.
+You never need think + commit separately. \`marrow_auto\` handles everything.
 
-## When you need more control
-
-1. **Session start:** Call marrow_orient FIRST. It surfaces failure warnings so you avoid known mistakes.
-2. **Before acting:** Call marrow_think with what you're about to do.
-3. **After acting:** Call marrow_commit with what happened.
+All Marrow API calls run in the background — \`marrow_auto\` returns instantly with cached warnings so you never wait.
 
 ## Query the hive
 
@@ -297,16 +647,27 @@ Use marrow_ask to query your decision history in plain English:
 - "what's our failure rate on security tasks?"
 - "what worked last time we published?"
 
+## Advanced mode: fine-grained control
+
+For cases where you need explicit control over the orient → think → act → commit loop:
+
+1. **Session start:** Call marrow_orient FIRST. It surfaces failure warnings so you avoid known mistakes.
+2. **Before acting:** Call marrow_think with what you're about to do. Returns pattern insights and recommendedNext — follow it.
+3. **After acting:** Call marrow_commit with what happened.
+4. **Shortcut:** marrow_run handles orient → think → commit in a single awaited call.
+
+Most agents never need advanced mode. \`marrow_auto\` covers 99% of cases.
+
 ## Why you must not skip this
 
 If you skip logging, the hive can't protect you or future agents from this mistake.
 Every decision you log compounds. Failure rates drop. Patterns emerge. The next session starts smarter.
 Marrow tells you what went wrong last time before you do it again. But only if you logged it.
 
-This is not optional overhead — it's how you stop repeating the same failures.`
-                        }
-                    }
-                ]
+This is not optional overhead — it's how you stop repeating the same failures.`,
+                        },
+                    },
+                ],
             });
             return;
         }
@@ -318,16 +679,9 @@ This is not optional overhead — it's how you stop repeating the same failures.
             const toolName = params?.name;
             const args = (params?.arguments || {});
             if (toolName === 'marrow_orient') {
-                const result = await (0, index_1.marrowOrient)(API_KEY, BASE_URL, {
-                    taskType: args.taskType,
-                }, SESSION_ID);
+                const result = await (0, index_1.marrowOrient)(API_KEY, BASE_URL, { taskType: args.taskType }, SESSION_ID);
                 success(id, {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(result, null, 2),
-                        },
-                    ],
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                 });
                 return;
             }
@@ -343,33 +697,27 @@ This is not optional overhead — it's how you stop repeating the same failures.
                 // Refresh orient warnings every 5th think call
                 thinkCallCount++;
                 if (thinkCallCount % 5 === 0) {
-                    refreshOrientWarnings().catch(() => { });
+                    refreshOrientWarnings();
                 }
-                // Inject orient warnings into EVERY think() response (not just first)
+                // Inject cached orient warnings into intelligence.insights
                 if (cachedOrientWarnings.length > 0) {
-                    const intel = result.intelligence;
-                    const existing = intel.insights || [];
-                    intel.insights = [
-                        ...cachedOrientWarnings.map(w => ({
+                    const existingInsights = result.intelligence?.insights || [];
+                    result.intelligence.insights = [
+                        ...cachedOrientWarnings.map((w) => ({
                             type: 'failure_pattern',
-                            summary: formatWarningActionably(w),
+                            summary: w.message,
                             action: `Review past ${w.type} failures before proceeding`,
-                            severity: w.failureRate > 0.4 ? 'critical' : 'warning',
+                            severity: (w.failureRate > 0.4 ? 'critical' : 'warning'),
                             count: 0,
                         })),
-                        ...existing,
+                        ...existingInsights,
                     ];
                 }
-                // Track for auto-commit on session close
+                // Track for auto-commit
                 lastDecisionId = result.decision_id;
                 lastCommitted = false;
                 success(id, {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(result, null, 2),
-                        },
-                    ],
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                 });
                 return;
             }
@@ -381,108 +729,209 @@ This is not optional overhead — it's how you stop repeating the same failures.
                     caused_by: args.caused_by,
                 }, SESSION_ID);
                 lastCommitted = true;
+                lastDecisionId = null;
                 success(id, {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(result, null, 2),
-                        },
-                    ],
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                 });
                 return;
             }
             if (toolName === 'marrow_run') {
-                const description = args.description;
-                const type = args.type || 'general';
-                const runSuccess = args.success;
-                const outcome = args.outcome;
+                // marrow_run = orient + think + commit in one call
+                await (0, index_1.marrowOrient)(API_KEY, BASE_URL, undefined, SESSION_ID);
                 const thinkResult = await (0, index_1.marrowThink)(API_KEY, BASE_URL, {
-                    action: description,
-                    type,
+                    action: args.description,
+                    type: args.type || 'general',
                 }, SESSION_ID);
                 const commitResult = await (0, index_1.marrowCommit)(API_KEY, BASE_URL, {
                     decision_id: thinkResult.decision_id,
-                    success: runSuccess,
-                    outcome,
+                    success: args.success ?? true,
+                    outcome: args.outcome,
                 }, SESSION_ID);
-                lastCommitted = true;
-                lastDecisionId = thinkResult.decision_id;
                 success(id, {
                     content: [
                         {
                             type: 'text',
-                            text: JSON.stringify({
-                                decision_id: thinkResult.decision_id,
-                                success_rate: commitResult.success_rate,
-                                insight: commitResult.insight,
-                                intelligence: thinkResult.intelligence,
-                            }, null, 2),
+                            text: JSON.stringify({ think: thinkResult, commit: commitResult }, null, 2),
                         },
                     ],
                 });
                 return;
             }
+            if (toolName === 'marrow_auto') {
+                // marrow_auto = fire-and-forget background logging
+                // Return immediately with cached orient warnings, API calls happen in background
+                const action = args.action;
+                const outcome = args.outcome;
+                const outcomeSuccess = args.success ?? true;
+                const type = args.type || 'general';
+                // Return cached warnings immediately
+                const response = {
+                    action,
+                    outcome: outcome || 'pending',
+                    warnings: cachedOrientWarnings.map(formatWarningActionably),
+                };
+                // Fire-and-forget the actual API calls
+                (async () => {
+                    try {
+                        if (!outcome) {
+                            // Intent only
+                            await (0, index_1.marrowThink)(API_KEY, BASE_URL, { action, type }, SESSION_ID);
+                        }
+                        else {
+                            // Full loop
+                            const thinkResult = await (0, index_1.marrowThink)(API_KEY, BASE_URL, { action, type }, SESSION_ID);
+                            await (0, index_1.marrowCommit)(API_KEY, BASE_URL, {
+                                decision_id: thinkResult.decision_id,
+                                success: outcomeSuccess,
+                                outcome,
+                            }, SESSION_ID);
+                        }
+                    }
+                    catch {
+                        // Silently fail - auto is best-effort
+                    }
+                })();
+                success(id, {
+                    content: [{ type: 'text', text: JSON.stringify(response, null, 2) }],
+                });
+                return;
+            }
             if (toolName === 'marrow_ask') {
-                const query = args.query;
-                if (!query) {
-                    error(id, -32602, 'query parameter is required');
-                    return;
-                }
-                const result = await (0, index_1.marrowAsk)(API_KEY, BASE_URL, { query }, SESSION_ID);
+                const result = await (0, index_1.marrowAsk)(API_KEY, BASE_URL, { query: args.query }, SESSION_ID);
                 success(id, {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(result, null, 2),
-                        },
-                    ],
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                 });
                 return;
             }
             if (toolName === 'marrow_status') {
                 const result = await (0, index_1.marrowStatus)(API_KEY, BASE_URL, SESSION_ID);
                 success(id, {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(result, null, 2),
-                        },
-                    ],
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                 });
                 return;
             }
-            error(id, -32601, `Unknown tool: ${toolName}`);
+            // Memory control tools
+            if (toolName === 'marrow_list_memories') {
+                const result = await marrowListMemories(API_KEY, BASE_URL, {
+                    status: args.status,
+                    query: args.query,
+                    limit: args.limit,
+                    agentId: args.agentId,
+                }, SESSION_ID);
+                success(id, {
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                });
+                return;
+            }
+            if (toolName === 'marrow_get_memory') {
+                const result = await marrowGetMemory(API_KEY, BASE_URL, args.id, SESSION_ID);
+                success(id, {
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                });
+                return;
+            }
+            if (toolName === 'marrow_update_memory') {
+                const result = await marrowUpdateMemory(API_KEY, BASE_URL, args.id, {
+                    text: args.text,
+                    source: args.source,
+                    tags: args.tags,
+                    actor: args.actor,
+                    note: args.note,
+                }, SESSION_ID);
+                success(id, {
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                });
+                return;
+            }
+            if (toolName === 'marrow_delete_memory') {
+                const result = await marrowDeleteMemory(API_KEY, BASE_URL, args.id, { actor: args.actor, note: args.note }, SESSION_ID);
+                success(id, {
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                });
+                return;
+            }
+            if (toolName === 'marrow_mark_outdated') {
+                const result = await marrowMarkOutdated(API_KEY, BASE_URL, args.id, { actor: args.actor, note: args.note }, SESSION_ID);
+                success(id, {
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                });
+                return;
+            }
+            if (toolName === 'marrow_supersede_memory') {
+                const result = await marrowSupersedeMemory(API_KEY, BASE_URL, args.id, {
+                    text: args.text,
+                    source: args.source,
+                    tags: args.tags,
+                    actor: args.actor,
+                    note: args.note,
+                }, SESSION_ID);
+                success(id, {
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                });
+                return;
+            }
+            if (toolName === 'marrow_share_memory') {
+                const result = await marrowShareMemory(API_KEY, BASE_URL, args.id, args.agentIds || [], args.actor, SESSION_ID);
+                success(id, {
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                });
+                return;
+            }
+            if (toolName === 'marrow_export_memories') {
+                const result = await marrowExportMemories(API_KEY, BASE_URL, {
+                    format: args.format,
+                    status: args.status,
+                    tags: args.tags,
+                }, SESSION_ID);
+                success(id, {
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                });
+                return;
+            }
+            if (toolName === 'marrow_import_memories') {
+                const result = await marrowImportMemories(API_KEY, BASE_URL, args.memories || [], args.mode || 'merge', SESSION_ID);
+                success(id, {
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                });
+                return;
+            }
+            if (toolName === 'marrow_retrieve_memories') {
+                const result = await marrowRetrieveMemories(API_KEY, BASE_URL, args.query, {
+                    limit: args.limit,
+                    from: args.from,
+                    to: args.to,
+                    tags: args.tags,
+                    source: args.source,
+                    status: args.status,
+                    shared: args.shared,
+                }, SESSION_ID);
+                success(id, {
+                    content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                });
+                return;
+            }
+            error(id, -32601, `Method not found: ${toolName}`);
             return;
         }
-        // Unknown method
         error(id, -32601, `Method not found: ${method}`);
     }
     catch (err) {
-        const msg = err instanceof Error ? err.message.slice(0, 200) : 'Internal error';
-        error(id, -32603, msg);
+        const message = err instanceof Error ? err.message : String(err);
+        error(id, -32000, message);
     }
 }
-// stdio server
+// MCP stdio loop
 const rl = readline.createInterface({
     input: process.stdin,
     output: process.stdout,
-    terminal: false,
 });
-rl.on('line', (line) => {
-    const trimmed = line.trim();
-    if (!trimmed)
-        return;
+rl.on('line', async (line) => {
     try {
-        const req = JSON.parse(trimmed);
-        handleRequest(req).catch((err) => {
-            process.stderr.write(`Unhandled error: ${err}\n`);
-        });
+        const msg = JSON.parse(line);
+        await handleRequest(msg);
     }
-    catch {
-        process.stderr.write(`Failed to parse request: ${trimmed}\n`);
+    catch (err) {
+        process.stderr.write(`[marrow] Parse error: ${err}\n`);
     }
 });
-rl.on('close', () => {
-    process.exit(0);
-});
 //# sourceMappingURL=cli.js.map