@getmarrow/mcp 2.8.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,7 +50,6 @@ if (!API_KEY) {
 // Auto-orient on startup — cache warnings, inject into EVERY marrow_think response
 let cachedOrientWarnings = [];
 let thinkCallCount = 0;
-// Pending decision map for marrow_auto (action hash → decision_id)
 const pendingDecisions = new Map();
 const PENDING_TTL_MS = 30 * 60 * 1000; // 30 min TTL
 function actionHash(action) {
@@ -56,8 +65,9 @@ function actionHash(action) {
 function cleanupPending() {
     const now = Date.now();
     for (const [key, val] of pendingDecisions) {
-        if (now - val.timestamp > PENDING_TTL_MS)
+        if (now - val.timestamp > PENDING_TTL_MS) {
             pendingDecisions.delete(key);
+        }
     }
 }
 function formatWarningActionably(w) {
@@ -69,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`);
     }
 });
@@ -92,7 +104,9 @@ async function autoCommitOnClose() {
             }, SESSION_ID);
             clearTimeout(timeout);
         }
-        catch { }
+        catch {
+            // ignore
+        }
     }
 }
 process.on('SIGTERM', async () => {
@@ -101,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');
 }
@@ -111,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 = [
     {
@@ -280,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) {
@@ -299,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;
         }
@@ -358,10 +664,10 @@ If you skip logging, the hive can't protect you or future agents from this mista
 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;
         }
@@ -373,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;
             }
@@ -398,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((e) => { process.stderr.write('[marrow] background op failed: ' + String(e) + '\n'); });
+                    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;
             }
@@ -436,191 +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 autoSuccess = args.success !== undefined ? args.success : true;
+                const outcomeSuccess = args.success ?? true;
                 const type = args.type || 'general';
-                if (!action) {
-                    error(id, -32602, 'action parameter is required');
-                    return;
-                }
-                // Collect warnings synchronously from cache — no API call
-                const warnings = cachedOrientWarnings.map(formatWarningActionably);
-                const hash = actionHash(action);
-                if (outcome) {
-                    // Full round-trip: think + commit, fire-and-forget
-                    const existingPending = pendingDecisions.get(hash);
-                    if (existingPending) {
-                        // Match a previous intent — commit against that decision
-                        const decisionId = existingPending.decision_id;
-                        pendingDecisions.delete(hash);
-                        (0, index_1.marrowCommit)(API_KEY, BASE_URL, {
-                            decision_id: decisionId,
-                            success: autoSuccess,
-                            outcome,
-                        }, SESSION_ID).then(() => { lastCommitted = true; }).catch((e) => { process.stderr.write('[marrow] background op failed: ' + String(e) + '\n'); });
-                        success(id, {
-                            content: [{ type: 'text', text: JSON.stringify({
-                                        warnings,
-                                        decision_id: decisionId,
-                                        message: 'Logged. Continue with your task.',
-                                    }, null, 2) }],
-                        });
-                    }
-                    else {
-                        // No pending — fire-and-forget think+commit
-                        (0, index_1.marrowThink)(API_KEY, BASE_URL, { action, type }, SESSION_ID)
-                            .then(thinkResult => {
-                            lastDecisionId = thinkResult.decision_id;
-                            return (0, index_1.marrowCommit)(API_KEY, BASE_URL, {
+                // 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: autoSuccess,
+                                success: outcomeSuccess,
                                 outcome,
                             }, SESSION_ID);
-                        })
-                            .then(() => { lastCommitted = true; })
-                            .catch((e) => { process.stderr.write('[marrow] background op failed: ' + String(e) + '\n'); });
-                        success(id, {
-                            content: [{ type: 'text', text: JSON.stringify({
-                                        warnings,
-                                        decision_id: null,
-                                        message: 'Logged. Continue with your task.',
-                                    }, null, 2) }],
-                        });
+                        }
                     }
-                }
-                else {
-                    // Intent only — fire-and-forget think, store decision_id when resolved
-                    cleanupPending();
-                    (0, index_1.marrowThink)(API_KEY, BASE_URL, { action, type }, SESSION_ID)
-                        .then(thinkResult => {
-                        pendingDecisions.set(hash, {
-                            decision_id: thinkResult.decision_id,
-                            action,
-                            timestamp: Date.now(),
-                        });
-                        lastDecisionId = thinkResult.decision_id;
-                        lastCommitted = false;
-                    })
-                        .catch((e) => { process.stderr.write('[marrow] background op failed: ' + String(e) + '\n'); });
-                    // Refresh orient warnings periodically
-                    thinkCallCount++;
-                    if (thinkCallCount % 5 === 0) {
-                        refreshOrientWarnings().catch((e) => { process.stderr.write('[marrow] background op failed: ' + String(e) + '\n'); });
+                    catch {
+                        // Silently fail - auto is best-effort
                     }
-                    success(id, {
-                        content: [{ type: 'text', text: JSON.stringify({
-                                    warnings,
-                                    decision_id: null,
-                                    message: 'Logged. Continue with your task.',
-                                }, null, 2) }],
-                    });
-                }
+                })();
+                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;
+            }
+            // 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, `Unknown tool: ${toolName}`);
+            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