memory-journal-mcp 7.0.1 → 7.1.0

package/README.md

@@ -10,7 +10,7 @@
 [![MCP Registry](https://img.shields.io/badge/MCP_Registry-Published-green)](https://registry.modelcontextprotocol.io/v0/servers?search=io.github.neverinfamous/memory-journal-mcp)
 [![Security](https://img.shields.io/badge/Security-Enhanced-green.svg)](SECURITY.md)
 [![TypeScript](https://img.shields.io/badge/TypeScript-Strict-blue.svg)](https://github.com/neverinfamous/memory-journal-mcp)
-![Coverage](https://img.shields.io/badge/Coverage-97.52%25-brightgreen.svg)
+![Coverage](https://img.shields.io/badge/Coverage-97.12%25-brightgreen.svg)
 ![Tests](https://img.shields.io/badge/Tests-1782_passed-brightgreen.svg)
 ![E2E Tests](https://img.shields.io/badge/E2E_Tests-391_passed-brightgreen.svg)
 [![CI](https://github.com/neverinfamous/memory-journal-mcp/actions/workflows/gatekeeper.yml/badge.svg)](https://github.com/neverinfamous/memory-journal-mcp/actions/workflows/gatekeeper.yml)
@@ -28,7 +28,7 @@
 
 ### What Sets Us Apart
 
-**61 MCP Tools** · **17 Workflow Prompts** · **38 Resources** · **10 Tool Groups** · **Code Mode** · **GitHub Commander** (Issue Triage, PR Review, Milestone Sprints, Security/Quality/Perf Audits) · **GitHub Integration** (Issues, PRs, Actions, Kanban, Milestones, Insights) · **Team Collaboration** (Shared DB, Vector Search, Cross-Project Insights)
+**65 MCP Tools** · **17 Workflow Prompts** · **38 Resources** · **10 Tool Groups** · **Code Mode** · **GitHub Commander** (Issue Triage, PR Review, Milestone Sprints, Security/Quality/Perf Audits) · **GitHub Integration** (Issues, PRs, Actions, Kanban, Milestones, Insights) · **Team Collaboration** (Shared DB, Vector Search, Cross-Project Insights)
 
 | Feature                       | Description                                                                                                                                                    |
 | ----------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- |
@@ -40,7 +40,8 @@
 | **Code Mode**                 | Execute multi-step operations in a secure sandbox — up to 90% token savings via `mj.*` API                                                                     |
 | **Configurable Briefing**     | 12 env vars / CLI flags control `memory://briefing` content — entries, team, GitHub detail, skills awareness                                                   |
 | **Reports & Analytics**       | Standups, retrospectives, PR summaries, digests, period analyses, and milestone tracking                                                                       |
-| **Team Collaboration**        | 20 tools with full parity — CRUD, vector search, relationship graphs, cross-project insights, author attribution                                               |
+| **Team Collaboration**        | 22 tools with full parity — CRUD, vector search, relationship graphs, cross-project insights, author attribution                                               |
+| **Data Interoperability**     | Bidirectional Markdown roundtripping, unified IO namespace, and schema-safe JSON exports with hard bounds-checked path traversal defenses                      |
 | **Backup & Restore**          | One-command backup/restore with automated scheduling, retention policies, and safety-net auto-backups                                                          |
 | **Security & Transport**      | OAuth 2.1 (RFC 9728/8414, JWT/JWKS, scopes), Streamable HTTP + SSE, rate limiting, CORS, SQL injection prevention, non-root Docker                             |
 | **Structured Error Handling** | Every tool returns `{success, error, code, category, suggestion, recoverable}` — agents get classification, remediation hints, and recoverability signals      |
@@ -149,18 +150,18 @@ Control which tools are exposed via `MEMORY_JOURNAL_MCP_TOOL_FILTER` (or CLI: `-
 
 | Filter               | Tools | Use Case                 |
 | -------------------- | ----- | ------------------------ |
-| `full`               | 61    | All tools (default)      |
+| `full`               | 65    | All tools (default)      |
 | `starter`            | ~11   | Core + search + codemode |
 | `essential`          | ~7    | Minimal footprint        |
 | `readonly`           | ~15   | Disable all mutations    |
-| `-github`            | 45    | Exclude a group          |
-| `-github,-analytics` | 43    | Exclude multiple groups  |
+| `-github`            | 49    | Exclude a group          |
+| `-github,-analytics` | 47    | Exclude multiple groups  |
 
 **Filter Syntax:** `shortcut` or `group` or `tool_name` (whitelist mode) · `-group` (disable group) · `-tool` (disable tool) · `+tool` (re-enable after group disable)
 
 **Custom Selection:** List individual tool names to create your own whitelist: `--tool-filter "create_entry,search_entries,semantic_search"`
 
-**Groups:** `core`, `search`, `analytics`, `relationships`, `export`, `admin`, `github`, `backup`, `team`, `codemode`
+**Groups:** `core`, `search`, `analytics`, `relationships`, `io`, `admin`, `github`, `backup`, `team`, `codemode`
 
 **[Complete tool filtering guide →](https://github.com/neverinfamous/memory-journal-mcp/wiki/Tool-Filtering)**
 
@@ -168,20 +169,20 @@ Control which tools are exposed via `MEMORY_JOURNAL_MCP_TOOL_FILTER` (or CLI: `-
 
 ## 📋 Core Capabilities
 
-### 🛠️ **61 MCP Tools** (10 Groups)
-
-| Group           | Tools | Description                                                                                                         |
-| --------------- | ----- | ------------------------------------------------------------------------------------------------------------------- |
-| `codemode`      | 1     | Code Mode (sandboxed code execution) 🌟 **Recommended**                                                             |
-| `core`          | 6     | Entry CRUD, tags, test                                                                                              |
-| `search`        | 4     | Text search, date range, semantic, vector stats                                                                     |
-| `analytics`     | 2     | Statistics, cross-project insights                                                                                  |
-| `relationships` | 2     | Link entries, visualize graphs                                                                                      |
-| `export`        | 1     | JSON/Markdown export                                                                                                |
-| `admin`         | 5     | Update, delete, rebuild/add to vector index, merge tags                                                             |
-| `github`        | 16    | Issues, PRs, context, Kanban, **Milestones**, **Insights**, **issue lifecycle**, **Copilot Reviews**                |
-| `backup`        | 4     | Backup, list, restore, cleanup                                                                                      |
-| `team`          | 20    | CRUD, search, stats, relationships, export, backup, vector search, cross-project insights (requires `TEAM_DB_PATH`) |
+### 🛠️ **65 MCP Tools** (10 Groups)
+
+| Group           | Tools | Description                                                                                                                              |
+| --------------- | ----- | ---------------------------------------------------------------------------------------------------------------------------------------- |
+| `codemode`      | 1     | Code Mode (sandboxed code execution) 🌟 **Recommended**                                                                                  |
+| `core`          | 6     | Entry CRUD, tags, test                                                                                                                   |
+| `search`        | 4     | Text search, date range, semantic, vector stats                                                                                          |
+| `analytics`     | 2     | Statistics, cross-project insights                                                                                                       |
+| `relationships` | 2     | Link entries, visualize graphs                                                                                                           |
+| `io`            | 3     | JSON/Markdown export and File-level Markdown Data Integration Interoperability (Import/Export)                                           |
+| `admin`         | 5     | Update, delete, rebuild/add to vector index, merge tags                                                                                  |
+| `github`        | 16    | Issues, PRs, context, Kanban, **Milestones**, **Insights**, **issue lifecycle**, **Copilot Reviews**                                     |
+| `backup`        | 4     | Backup, list, restore, cleanup                                                                                                           |
+| `team`          | 22    | CRUD, search, stats, relationships, IO (Markdown import/export), backup, vector search, cross-project insights (requires `TEAM_DB_PATH`) |
 
 **[Complete tools reference →](https://github.com/neverinfamous/memory-journal-mcp/wiki/Tools)**
 
@@ -268,7 +269,7 @@ Code executes in a **sandboxed VM context** with multiple layers of security. Al
 
 ### ⚡ Code Mode Only (Maximum Token Savings)
 
-Run with **only Code Mode enabled** — a single tool that provides access to all 61 tools' worth of capability through the `mj.*` API:
+Run with **only Code Mode enabled** — a single tool that provides access to all 65 tools' worth of capability through the `mj.*` API:
 
 ```json
 {
@@ -554,7 +555,7 @@ For production deployments, enable OAuth 2.1 authentication on the HTTP transpor
 
 | Scope   | Tool Groups                                       |
 | ------- | ------------------------------------------------- |
-| `read`  | core, search, analytics, relationships, export    |
+| `read`  | core, search, analytics, relationships, io        |
 | `write` | github, team (+ all read groups)                  |
 | `admin` | admin, backup, codemode (+ all write/read groups) |
 
@@ -628,7 +629,7 @@ flowchart TB
     AI["🤖 AI Agent<br/>(Cursor, Windsurf, Claude)"]
 
     subgraph MCP["Memory Journal MCP Server"]
-        Tools["🛠️ 61 Tools"]
+        Tools["🛠️ 65 Tools"]
         Resources["📡 38 Resources"]
         Prompts["💬 17 Prompts"]
     end
@@ -657,7 +658,7 @@ flowchart TB
 ┌─────────────────────────────────────────────────────────────┐
 │ MCP Server Layer (TypeScript)                               │
 │  ┌─────────────────┐  ┌─────────────────┐  ┌─────────────┐  │
-│  │ Tools (61)      │  │ Resources (38)  │  │ Prompts (17)│  │
+│  │ Tools (65)      │  │ Resources (38)  │  │ Prompts (17)│  │
 │  │ with Annotations│  │ with Annotations│  │             │  │
 │  └─────────────────┘  └─────────────────┘  └─────────────┘  │
 ├─────────────────────────────────────────────────────────────┤

package/dist/{chunk-ARLH46WS.js → chunk-37BQOJDZ.js}

@@ -222,6 +222,13 @@ function assertNoPathTraversal(filename) {
     throw new PathTraversalError(filename);
   }
 }
+function assertSafeDirectoryPath(dirPath) {
+  const normalized = dirPath.replace(/\\/g, "/");
+  const segments = normalized.split("/");
+  if (segments.some((s) => s === "..")) {
+    throw new PathTraversalError(dirPath);
+  }
+}
 var TOKEN_PATTERNS = [
   // GitHub personal access tokens (classic and fine-grained)
   /ghp_[A-Za-z0-9_]{36,}/g,
@@ -1656,4 +1663,4 @@ var GitHubIntegration = class {
   }
 };
 
-export { ConfigurationError, ConnectionError, GitHubIntegration, MemoryJournalMcpError, QueryError, ResourceNotFoundError, ValidationError, assertNoPathTraversal, logger, matchSuggestion, resolveAuthor, validateDateFormatPattern };
+export { ConfigurationError, ConnectionError, GitHubIntegration, MemoryJournalMcpError, QueryError, ResourceNotFoundError, ValidationError, assertNoPathTraversal, assertSafeDirectoryPath, logger, matchSuggestion, resolveAuthor, validateDateFormatPattern };

package/dist/{chunk-6J4RPJ4I.js → chunk-GW5DYUQJ.js}

@@ -1,5 +1,5 @@
-import { withSessionInit, withPriority, ASSISTANT_FOCUSED, TOOL_GROUPS, HIGH_PRIORITY, LOW_PRIORITY, MEDIUM_PRIORITY, setDefaultSandboxMode, initializeAuditLogger, parseToolFilter, getFilterSummary, getToolFilterFromEnv, getTools, getEnabledGroups, callTool, getGlobalAuditLogger, sendProgress, SUPPORTED_SCOPES, getRequiredScope, hasScope, getAuditResourceDef, execQuery, transformEntryRow, resolveGitHubRepo, isResourceError, milestoneCompletionPct, parseScopes, BASE_SCOPES, getAllToolNames, globalMetrics, DEFAULT_BRIEFING_CONFIG } from './chunk-2BJHLTYP.js';
-import { logger, GitHubIntegration, ConfigurationError, ResourceNotFoundError, ConnectionError, QueryError, assertNoPathTraversal, ValidationError, MemoryJournalMcpError, validateDateFormatPattern } from './chunk-ARLH46WS.js';
+import { withSessionInit, withPriority, ASSISTANT_FOCUSED, TOOL_GROUPS, HIGH_PRIORITY, LOW_PRIORITY, MEDIUM_PRIORITY, setDefaultSandboxMode, initializeAuditLogger, parseToolFilter, getFilterSummary, getToolFilterFromEnv, getTools, getEnabledGroups, callTool, getGlobalAuditLogger, sendProgress, SUPPORTED_SCOPES, getRequiredScope, hasScope, getAuditResourceDef, execQuery, transformEntryRow, resolveGitHubRepo, isResourceError, milestoneCompletionPct, parseScopes, BASE_SCOPES, getAllToolNames, globalMetrics, DEFAULT_BRIEFING_CONFIG } from './chunk-JEGRDY6W.js';
+import { logger, GitHubIntegration, ConfigurationError, ResourceNotFoundError, ConnectionError, QueryError, assertNoPathTraversal, ValidationError, MemoryJournalMcpError, validateDateFormatPattern } from './chunk-37BQOJDZ.js';
 import { createRequire } from 'module';
 import { McpServer, ResourceTemplate } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
@@ -2445,10 +2445,10 @@ var CODE_MODE_NAMESPACE_ROWS = [
     example: '`mj.relationships.linkEntries(1, 2, "implements")`'
   },
   {
-    group: "export",
-    label: "Export",
-    namespace: "`mj.export.*`",
-    example: '`mj.export.exportEntries("json")`'
+    group: "io",
+    label: "IO",
+    namespace: "`mj.io.*`",
+    example: '`mj.io.exportEntries("json")`'
   },
   {
     group: "admin",
@@ -2502,7 +2502,7 @@ This executes JavaScript in a sandboxed environment with all tools available as
 | Search        | \`mj.search.*\`        | \`mj.search.searchEntries("performance")\`           |
 | Analytics     | \`mj.analytics.*\`     | \`mj.analytics.getStatistics()\`                     |
 | Relationships | \`mj.relationships.*\` | \`mj.relationships.linkEntries(1, 2, "implements")\` |
-| Export        | \`mj.export.*\`        | \`mj.export.exportEntries("json")\`                  |
+| IO            | \`mj.io.*\`            | \`mj.io.exportEntries("json")\`                      |
 | Admin         | \`mj.admin.*\`         | \`mj.admin.rebuildVectorIndex()\`                    |
 | GitHub        | \`mj.github.*\`        | \`mj.github.getGithubIssues({ state: "open" })\`     |
 | Backup        | \`mj.backup.*\`        | \`mj.backup.backupJournal()\`                        |
@@ -2626,7 +2626,7 @@ var GOTCHAS_CONTENT = `# memory-journal-mcp \u2014 Field Notes & Gotchas
 
 - **Team cross-database search**: \`search_entries\` and \`search_by_date_range\` automatically merge team DB results when \`TEAM_DB_PATH\` is configured. Results include a \`source\` field ("personal" or "team").
 - **Team vector search**: Team has its own isolated vector index. Use \`team_rebuild_vector_index\` if the team index drifts. \`team_semantic_search\` works identically to personal \`semantic_search\`.
-- **Team tools without \`TEAM_DB_PATH\`**: All 20 team tools return \`{ success: false, error: "Team collaboration is not configured..." }\` \u2014 no crash, no partial results.
+- **Team tools without \`TEAM_DB_PATH\`**: All 22 team tools return \`{ success: false, error: "Team collaboration is not configured..." }\` \u2014 no crash, no partial results.
 `;
 function generateInstructions(enabledTools, prompts, latestEntry, level = "standard", enabledGroups) {
   const groups = enabledGroups ?? getEnabledGroups(enabledTools);
@@ -4692,7 +4692,7 @@ var GROUP_DESCRIPTIONS = {
   search: "Full-text search, semantic search, date range queries, and vector index stats",
   analytics: "Entry analytics, importance scoring, and productivity trends",
   relationships: "Link and visualize relationships between journal entries",
-  export: "Export journal data in various formats (JSON, Markdown, CSV)",
+  io: "Import and export journal data \u2014 JSON export, Markdown round-trip (export/import)",
   admin: "Update entries, rebuild indexes, and manage the vector search index",
   github: "GitHub integration \u2014 issues, PRs, milestones, workflow runs, Kanban boards",
   backup: "Create and restore database backups",
@@ -4894,7 +4894,7 @@ function getHelpResourceDefinitions() {
 var toolIndexModule = null;
 async function getAllToolDefinitionsAsync(context) {
   try {
-    toolIndexModule ??= await import('./tools-FFFGXIKN.js');
+    toolIndexModule ??= await import('./tools-O44Q52RD.js');
     if (toolIndexModule === null) return [];
     const tools = toolIndexModule.getTools(context.db, null);
     return tools.map((t) => ({
@@ -4935,8 +4935,10 @@ function inferGroupFromName(name) {
     // relationships (2)
     link_entries: "relationships",
     visualize_relationships: "relationships",
-    // export (1)
-    export_entries: "export",
+    // io (3)
+    export_entries: "io",
+    export_markdown: "io",
+    import_markdown: "io",
     // admin (5)
     update_entry: "admin",
     delete_entry: "admin",

package/dist/{chunk-2BJHLTYP.js → chunk-JEGRDY6W.js}

@@ -1,14 +1,15 @@
 import { transformAutoReturn } from './chunk-OKOVZ5QE.js';
-import { GitHubIntegration, resolveAuthor, logger, MemoryJournalMcpError, matchSuggestion, ConfigurationError } from './chunk-ARLH46WS.js';
+import { GitHubIntegration, resolveAuthor, logger, assertSafeDirectoryPath, MemoryJournalMcpError, matchSuggestion, ConfigurationError } from './chunk-37BQOJDZ.js';
 import { z, ZodError } from 'zod';
+import { open, stat, mkdir, rename, appendFile, readdir, readFile } from 'fs/promises';
+import { tmpdir } from 'os';
+import * as path from 'path';
+import { dirname, resolve, sep, join } from 'path';
 import * as vm from 'vm';
 import { MessageChannel, Worker } from 'worker_threads';
 import * as crypto2 from 'crypto';
 import { fileURLToPath } from 'url';
-import * as path from 'path';
-import { dirname } from 'path';
 import { performance as performance$1 } from 'perf_hooks';
-import { open, stat, mkdir, rename, appendFile } from 'fs/promises';
 
 function formatZodError(error) {
   return error.issues.map((issue) => {
@@ -58,7 +59,7 @@ async function resolveIssueUrl(context, projectNumber, issueNumber, existingUrl)
       ([_, v]) => v.project_number === projectNumber
     );
     if (entry) {
-      const { GitHubIntegration: GitHubIntegration2 } = await import('./github-integration-PDRLXKGM.js');
+      const { GitHubIntegration: GitHubIntegration2 } = await import('./github-integration-FOJ4U6I5.js');
       const targetGithub = new GitHubIntegration2(entry[1].path);
       const repoInfo = await targetGithub.getRepoInfo();
       if (repoInfo.owner && repoInfo.repo) {
@@ -1261,12 +1262,23 @@ var LinkEntriesSchemaMcp = z.object({
 var VisualizeInputSchema = z.object({
   entry_id: z.number().optional().describe("Specific entry ID to visualize (shows connected entries)"),
   tags: z.array(z.string()).optional().describe("Filter entries by tags"),
+  relationship_type: z.enum([
+    "evolves_from",
+    "references",
+    "implements",
+    "clarifies",
+    "response_to",
+    "blocked_by",
+    "resolved",
+    "caused"
+  ]).optional().describe("Filter to show only this relationship type"),
   depth: z.number().min(1).max(3).optional().default(2).describe("Relationship traversal depth"),
   limit: z.number().max(500).optional().default(20).describe("Maximum entries to include")
 });
 var VisualizeInputSchemaMcp = z.object({
   entry_id: relaxedNumber().optional().describe("Specific entry ID to visualize (shows connected entries)"),
   tags: z.array(z.string()).optional().describe("Filter entries by tags"),
+  relationship_type: z.string().optional().describe("Filter to show only this relationship type (e.g., blocked_by, implements)"),
   depth: relaxedNumber().optional().default(2).describe("Relationship traversal depth"),
   limit: relaxedNumber().optional().default(20).describe("Maximum entries to include")
 });
@@ -1463,15 +1475,18 @@ function getRelationshipTools(context) {
           }
           const entryIds = Object.keys(entries).map(Number);
           const placeholders = entryIds.map(() => "?").join(",");
-          const relsResult = db.executeRawQuery(
-            `
+          let relsQuery = `
                         SELECT from_entry_id, to_entry_id, relationship_type
                         FROM relationships
                         WHERE from_entry_id IN (${placeholders})
                           AND to_entry_id IN (${placeholders})
-                    `,
-            [...entryIds, ...entryIds]
-          );
+                    `;
+          const relsParams = [...entryIds, ...entryIds];
+          if (input.relationship_type) {
+            relsQuery += " AND relationship_type = ?";
+            relsParams.push(input.relationship_type);
+          }
+          const relsResult = db.executeRawQuery(relsQuery, relsParams);
           const relationships = relsResult[0]?.values ?? [];
           const MERMAID_CONTENT_PREVIEW_LENGTH = 40;
           let mermaid = "```mermaid\\ngraph TD\\n";
@@ -1554,8 +1569,345 @@ async function sendProgress(ctx, progress, total, message) {
   } catch {
   }
 }
+var FrontmatterSchema = z.object({
+  mj_id: z.number().int().positive().optional(),
+  entry_type: z.string().optional(),
+  author: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+  timestamp: z.string().optional(),
+  significance: z.string().optional(),
+  relationships: z.array(
+    z.object({
+      type: z.string(),
+      target_id: z.number().int().positive()
+    })
+  ).optional(),
+  source: z.string().optional()
+});
+function serializeFrontmatter(data) {
+  if (data === null || data === void 0) return "";
+  const lines = ["---"];
+  if (data.mj_id !== void 0) lines.push(`mj_id: ${String(data.mj_id)}`);
+  if (data.entry_type !== void 0) lines.push(`entry_type: ${data.entry_type}`);
+  if (data.author !== void 0) lines.push(`author: ${data.author}`);
+  if (data.timestamp !== void 0) lines.push(`timestamp: ${data.timestamp}`);
+  if (data.significance !== void 0) lines.push(`significance: ${data.significance}`);
+  if (data.source !== void 0) lines.push(`source: ${data.source}`);
+  if (data.tags && data.tags.length > 0) {
+    lines.push("tags:");
+    for (const tag of data.tags) {
+      lines.push(`  - ${tag}`);
+    }
+  }
+  if (data.relationships !== void 0 && data.relationships.length > 0) {
+    lines.push("relationships:");
+    for (const rel of data.relationships) {
+      lines.push(`  - type: ${rel.type}`);
+      lines.push(`    target_id: ${String(rel.target_id)}`);
+    }
+  }
+  if (lines.length === 1) {
+    return "";
+  }
+  lines.push("---");
+  return lines.join("\n") + "\n";
+}
+function parseFrontmatter(content) {
+  const lines = content.split("\n");
+  if (lines[0]?.trim() !== "---") {
+    return { metadata: {}, body: content };
+  }
+  let closingIndex = -1;
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i]?.trim() === "---") {
+      closingIndex = i;
+      break;
+    }
+  }
+  if (closingIndex === -1) {
+    return { metadata: {}, body: content };
+  }
+  const fmLines = lines.slice(1, closingIndex);
+  const raw = {};
+  let currentKey = null;
+  let currentArray = null;
+  let isRelationshipArray = false;
+  let currentRelObj = null;
+  for (const line of fmLines) {
+    if (line.trim() === "") continue;
+    if (/^\s{2,}- /.test(line)) {
+      const itemContent = line.replace(/^\s{2,}- /, "");
+      if (isRelationshipArray && currentKey === "relationships") {
+        const colonIdx2 = itemContent.indexOf(":");
+        if (colonIdx2 !== -1) {
+          if (currentRelObj !== null) {
+            currentArray?.push(currentRelObj);
+          }
+          currentRelObj = {};
+          const key = itemContent.slice(0, colonIdx2).trim();
+          const value = itemContent.slice(colonIdx2 + 1).trim();
+          currentRelObj[key] = parseScalar(value);
+        }
+      } else if (currentArray !== null) {
+        currentArray.push(itemContent.trim());
+      }
+      continue;
+    }
+    if (/^\s{4,}\w/.test(line) && currentRelObj !== null) {
+      const colonIdx2 = line.indexOf(":");
+      if (colonIdx2 !== -1) {
+        const key = line.slice(0, colonIdx2).trim();
+        const value = line.slice(colonIdx2 + 1).trim();
+        currentRelObj[key] = parseScalar(value);
+      }
+      continue;
+    }
+    if (currentKey !== null && currentArray !== null) {
+      if (isRelationshipArray && currentRelObj !== null) {
+        currentArray.push(currentRelObj);
+        currentRelObj = null;
+      }
+      raw[currentKey] = currentArray;
+      currentArray = null;
+      currentKey = null;
+      isRelationshipArray = false;
+    }
+    const colonIdx = line.indexOf(":");
+    if (colonIdx !== -1) {
+      const key = line.slice(0, colonIdx).trim();
+      const value = line.slice(colonIdx + 1).trim();
+      if (value === "") {
+        currentKey = key;
+        currentArray = [];
+        isRelationshipArray = key === "relationships";
+      } else {
+        raw[key] = parseScalar(value);
+      }
+    }
+  }
+  if (currentKey !== null && currentArray !== null) {
+    if (isRelationshipArray && currentRelObj !== null) {
+      currentArray.push(currentRelObj);
+    }
+    raw[currentKey] = currentArray;
+  }
+  const parseResult = FrontmatterSchema.safeParse(raw);
+  if (!parseResult.success) {
+    const issues = parseResult.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`);
+    throw new Error(`Invalid frontmatter: ${issues.join("; ")}`);
+  }
+  const body = lines.slice(closingIndex + 1).join("\n").replace(/^\n/, "");
+  return { metadata: parseResult.data, body };
+}
+function parseScalar(value) {
+  if (/^-?\d+$/.test(value)) return parseInt(value, 10);
+  if (/^-?\d+\.\d+$/.test(value)) return parseFloat(value);
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+function generateSlug(content) {
+  const slug = content.slice(0, 50).toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-");
+  return slug || "untitled";
+}
+function generateFilename(id, content) {
+  return `${String(id)}-${generateSlug(content)}.md`;
+}
+async function exportEntriesToMarkdown(entries, outputDir, db) {
+  const resolvedOutputDir = resolve(outputDir);
+  const resolvedTmpDir = resolve(tmpdir());
+  const tmpPrefix = resolvedTmpDir.endsWith(sep) ? resolvedTmpDir : resolvedTmpDir + sep;
+  if (resolvedOutputDir === resolvedTmpDir || resolvedOutputDir.startsWith(tmpPrefix)) {
+    throw new Error("Refusing to export markdown files into the OS temporary directory");
+  }
+  await mkdir(resolvedOutputDir, { recursive: true });
+  const files = [];
+  let skipped = 0;
+  for (const entry of entries) {
+    if (!entry.content.trim()) {
+      skipped++;
+      continue;
+    }
+    const fmData = {
+      mj_id: entry.id,
+      entry_type: entry.entryType,
+      timestamp: entry.timestamp,
+      source: "memory-journal-mcp"
+    };
+    if (entry.tags !== void 0 && entry.tags.length > 0) {
+      fmData.tags = entry.tags;
+    }
+    if (entry.significance !== void 0) {
+      fmData.significance = entry.significance;
+    }
+    if (entry.author !== void 0) {
+      fmData.author = entry.author;
+    }
+    try {
+      const relationships = db.getRelationships(entry.id);
+      if (relationships.length > 0) {
+        fmData.relationships = relationships.map((r) => ({
+          type: r.relationshipType,
+          target_id: r.fromEntryId === entry.id ? r.toEntryId : r.fromEntryId
+        }));
+      }
+    } catch {
+    }
+    const frontmatter = serializeFrontmatter(fmData);
+    const fileContent = frontmatter + "\n" + entry.content + "\n";
+    const filename = generateFilename(entry.id, entry.content);
+    const filepath = join(resolvedOutputDir, filename);
+    const handle = await open(filepath, "w", 384);
+    try {
+      await handle.writeFile(fileContent, "utf-8");
+    } finally {
+      await handle.close();
+    }
+    files.push(filename);
+  }
+  return {
+    success: true,
+    exported_count: files.length,
+    output_dir: resolvedOutputDir,
+    files,
+    skipped
+  };
+}
+var VALID_RELATIONSHIP_TYPES = /* @__PURE__ */ new Set([
+  "evolves_from",
+  "references",
+  "implements",
+  "clarifies",
+  "response_to",
+  "blocked_by",
+  "resolved",
+  "caused"
+]);
+var VALID_ENTRY_TYPES = /* @__PURE__ */ new Set([
+  "personal_reflection",
+  "project_decision",
+  "technical_achievement",
+  "bug_fix",
+  "feature_implementation",
+  "code_review",
+  "meeting_notes",
+  "learning",
+  "research",
+  "planning",
+  "retrospective",
+  "standup",
+  "technical_note",
+  "development_note",
+  "enhancement",
+  "milestone",
+  "system_integration_test",
+  "test_entry",
+  "other"
+]);
+function toEntryType(value) {
+  if (value === void 0) return void 0;
+  return VALID_ENTRY_TYPES.has(value) ? value : void 0;
+}
+async function importMarkdownEntries(sourceDir, db, options = {}, vectorManager) {
+  const { dry_run = false, limit = 100 } = options;
+  const allFiles = await readdir(sourceDir);
+  const mdFiles = allFiles.filter((f) => f.endsWith(".md")).slice(0, limit);
+  const result = {
+    success: true,
+    created: 0,
+    updated: 0,
+    skipped: 0,
+    errors: [],
+    dry_run
+  };
+  for (const filename of mdFiles) {
+    try {
+      const filepath = join(sourceDir, filename);
+      const content = await readFile(filepath, "utf-8");
+      const { metadata, body } = parseFrontmatter(content);
+      if (!body.trim()) {
+        result.skipped++;
+        continue;
+      }
+      if (dry_run) {
+        if (metadata.mj_id !== void 0) {
+          const existing = db.getEntryById(metadata.mj_id);
+          if (existing) {
+            result.updated++;
+          } else {
+            result.created++;
+          }
+        } else {
+          result.created++;
+        }
+        continue;
+      }
+      let entryId;
+      const entryType = toEntryType(metadata.entry_type) ?? "personal_reflection";
+      if (metadata.mj_id !== void 0) {
+        const existing = db.getEntryById(metadata.mj_id);
+        if (existing) {
+          db.updateEntry(metadata.mj_id, {
+            content: body,
+            entryType: toEntryType(metadata.entry_type),
+            tags: metadata.tags
+          });
+          entryId = metadata.mj_id;
+          result.updated++;
+        } else {
+          const newEntry = db.createEntry({
+            content: body,
+            entryType,
+            tags: metadata.tags,
+            ...metadata.significance !== void 0 && {
+              significanceType: metadata.significance
+            }
+          });
+          entryId = newEntry.id;
+          result.created++;
+        }
+      } else {
+        const newEntry = db.createEntry({
+          content: body,
+          entryType,
+          tags: metadata.tags,
+          ...metadata.significance !== void 0 && {
+            significanceType: metadata.significance
+          }
+        });
+        entryId = newEntry.id;
+        result.created++;
+      }
+      if (metadata.relationships !== void 0) {
+        for (const rel of metadata.relationships) {
+          if (!VALID_RELATIONSHIP_TYPES.has(rel.type)) continue;
+          try {
+            const targetExists = db.getEntryById(rel.target_id);
+            if (targetExists) {
+              db.linkEntries(entryId, rel.target_id, rel.type);
+            }
+          } catch {
+          }
+        }
+      }
+      if (vectorManager) {
+        void vectorManager.addEntry(entryId, body).catch(() => {
+        });
+      }
+    } catch (err) {
+      result.errors.push({
+        file: filename,
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  return result;
+}
 
-// src/handlers/tools/export.ts
+// src/handlers/tools/io.ts
 var ExportEntriesSchema = z.object({
   format: z.enum(["json", "markdown"]).optional().default("json"),
   start_date: z.string().regex(DATE_FORMAT_REGEX, DATE_FORMAT_MESSAGE).optional(),
@@ -1580,14 +1932,60 @@ var ExportEntriesOutputSchema = z.object({
   success: z.boolean().optional(),
   error: z.string().optional()
 }).extend(ErrorFieldsMixin.shape);
-function getExportTools(context) {
+var ExportMarkdownSchema = z.object({
+  output_dir: z.string().min(1),
+  start_date: z.string().regex(DATE_FORMAT_REGEX, DATE_FORMAT_MESSAGE).optional(),
+  end_date: z.string().regex(DATE_FORMAT_REGEX, DATE_FORMAT_MESSAGE).optional(),
+  entry_types: z.array(z.enum(ENTRY_TYPES)).optional(),
+  tags: z.array(z.string()).optional(),
+  limit: z.number().max(500).optional().default(100)
+});
+var ExportMarkdownSchemaMcp = z.object({
+  output_dir: z.string().describe("Target directory for .md files"),
+  start_date: z.string().optional().describe("Start date filter (YYYY-MM-DD)"),
+  end_date: z.string().optional().describe("End date filter (YYYY-MM-DD)"),
+  entry_types: z.array(z.string()).optional().describe("Filter by entry types"),
+  tags: z.array(z.string()).optional().describe("Filter by tags"),
+  limit: relaxedNumber().optional().default(100).describe("Max entries to export (default: 100, max: 500)")
+});
+var ExportMarkdownOutputSchema = z.object({
+  success: z.boolean().optional(),
+  exported_count: z.number().optional(),
+  output_dir: z.string().optional(),
+  files: z.array(z.string()).optional(),
+  skipped: z.number().optional()
+}).extend(ErrorFieldsMixin.shape);
+var ImportMarkdownSchema = z.object({
+  source_dir: z.string().min(1),
+  dry_run: z.boolean().optional().default(false),
+  limit: z.number().max(500).optional().default(100)
+});
+var ImportMarkdownSchemaMcp = z.object({
+  source_dir: z.string().describe("Directory containing .md files to import"),
+  dry_run: z.boolean().optional().default(false).describe("Parse and validate without writing to database"),
+  limit: relaxedNumber().optional().default(100).describe("Max files to process (default: 100, max: 500)")
+});
+var ImportMarkdownOutputSchema = z.object({
+  success: z.boolean().optional(),
+  created: z.number().optional(),
+  updated: z.number().optional(),
+  skipped: z.number().optional(),
+  errors: z.array(
+    z.object({
+      file: z.string(),
+      error: z.string()
+    })
+  ).optional(),
+  dry_run: z.boolean().optional()
+}).extend(ErrorFieldsMixin.shape);
+function getIoTools(context) {
   const { db, progress } = context;
   return [
     {
       name: "export_entries",
       title: "Export Entries",
       description: "Export journal entries to JSON or Markdown format",
-      group: "export",
+      group: "io",
       inputSchema: ExportEntriesSchemaMcp,
       outputSchema: ExportEntriesOutputSchema,
       annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: false },
@@ -1643,6 +2041,111 @@ ${e.content}
           return formatHandlerError(err);
         }
       }
+    },
+    // ==================================================================
+    // export_markdown
+    // ==================================================================
+    {
+      name: "export_markdown",
+      title: "Export to Markdown Files",
+      description: "Export journal entries as individual frontmattered Markdown files (.md). Each file contains YAML frontmatter (mj_id, entry_type, tags, relationships) and the entry content. Files can be edited externally and re-imported via import_markdown.",
+      group: "io",
+      inputSchema: ExportMarkdownSchemaMcp,
+      outputSchema: ExportMarkdownOutputSchema,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      handler: async (params) => {
+        try {
+          const input = ExportMarkdownSchema.parse(params);
+          assertSafeDirectoryPath(input.output_dir);
+          await sendProgress(progress, 0, 3, "Fetching entries...");
+          const limit = input.limit ?? 100;
+          let entries;
+          if (input.start_date || input.end_date) {
+            const startDate = input.start_date ?? DATE_MIN_SENTINEL;
+            const endDate = input.end_date ?? DATE_MAX_SENTINEL;
+            entries = db.searchByDateRange(startDate, endDate, {
+              tags: input.tags,
+              limit
+            });
+          } else if (input.tags && input.tags.length > 0) {
+            entries = db.searchByDateRange(DATE_MIN_SENTINEL, DATE_MAX_SENTINEL, {
+              tags: input.tags,
+              limit
+            });
+          } else {
+            entries = db.getRecentEntries(limit);
+          }
+          if (input.entry_types && input.entry_types.length > 0) {
+            const allowedTypes = new Set(input.entry_types);
+            entries = entries.filter((e) => allowedTypes.has(e.entryType)).slice(0, limit);
+          }
+          await sendProgress(
+            progress,
+            1,
+            3,
+            `Exporting ${String(entries.length)} entries...`
+          );
+          const exportable = entries.map((e) => ({
+            id: e.id,
+            content: e.content,
+            entryType: e.entryType,
+            timestamp: e.timestamp,
+            tags: e.tags,
+            significance: e.significanceType ?? void 0
+          }));
+          const result = await exportEntriesToMarkdown(
+            exportable,
+            input.output_dir,
+            db
+          );
+          await sendProgress(progress, 3, 3, "Export complete");
+          return result;
+        } catch (err) {
+          return formatHandlerError(err);
+        }
+      }
+    },
+    // ==================================================================
+    // import_markdown
+    // ==================================================================
+    {
+      name: "import_markdown",
+      title: "Import from Markdown Files",
+      description: "Import frontmattered Markdown files (.md) into the journal. If a file has an mj_id in its frontmatter and the entry exists, it is updated. Otherwise, a new entry is created. Tags and relationships are reconciled automatically. Use dry_run: true to preview what would happen without writing.",
+      group: "io",
+      inputSchema: ImportMarkdownSchemaMcp,
+      outputSchema: ImportMarkdownOutputSchema,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      },
+      handler: async (params) => {
+        try {
+          const input = ImportMarkdownSchema.parse(params);
+          assertSafeDirectoryPath(input.source_dir);
+          await sendProgress(progress, 0, 2, "Reading markdown files...");
+          const result = await importMarkdownEntries(
+            input.source_dir,
+            db,
+            {
+              dry_run: input.dry_run,
+              limit: input.limit
+            },
+            context.vectorManager
+          );
+          await sendProgress(progress, 2, 2, "Import complete");
+          return result;
+        } catch (err) {
+          return formatHandlerError(err);
+        }
+      }
     }
   ];
 }
@@ -5015,6 +5518,179 @@ function getTeamExportTools(context) {
     }
   ];
 }
+var TeamExportMarkdownSchema = z.object({
+  output_dir: z.string().min(1),
+  start_date: z.string().regex(DATE_FORMAT_REGEX, DATE_FORMAT_MESSAGE).optional(),
+  end_date: z.string().regex(DATE_FORMAT_REGEX, DATE_FORMAT_MESSAGE).optional(),
+  tags: z.array(z.string()).optional(),
+  limit: z.number().max(500).optional().default(100)
+});
+var TeamExportMarkdownSchemaMcp = z.object({
+  output_dir: z.string().describe("Target directory for .md files"),
+  start_date: z.string().optional().describe("Start date filter (YYYY-MM-DD)"),
+  end_date: z.string().optional().describe("End date filter (YYYY-MM-DD)"),
+  tags: z.array(z.string()).optional().describe("Filter by tags"),
+  limit: relaxedNumber().optional().default(100).describe("Max entries to export (default: 100, max: 500)")
+});
+var TeamExportMarkdownOutputSchema = z.object({
+  success: z.boolean().optional(),
+  exported_count: z.number().optional(),
+  output_dir: z.string().optional(),
+  files: z.array(z.string()).optional(),
+  skipped: z.number().optional()
+}).extend(ErrorFieldsMixin.shape);
+var TeamImportMarkdownSchema = z.object({
+  source_dir: z.string().min(1),
+  dry_run: z.boolean().optional().default(false),
+  limit: z.number().max(500).optional().default(100)
+});
+var TeamImportMarkdownSchemaMcp = z.object({
+  source_dir: z.string().describe("Directory containing .md files to import"),
+  dry_run: z.boolean().optional().default(false).describe("Parse and validate without writing to database"),
+  limit: relaxedNumber().optional().default(100).describe("Max files to process (default: 100, max: 500)")
+});
+var TeamImportMarkdownOutputSchema = z.object({
+  success: z.boolean().optional(),
+  created: z.number().optional(),
+  updated: z.number().optional(),
+  skipped: z.number().optional(),
+  errors: z.array(z.object({ file: z.string(), error: z.string() })).optional(),
+  dry_run: z.boolean().optional()
+}).extend(ErrorFieldsMixin.shape);
+function getTeamIoTools(context) {
+  const { teamDb, progress } = context;
+  if (!teamDb) {
+    return [
+      {
+        name: "team_export_markdown",
+        title: "Team Export to Markdown",
+        description: "Export team entries as frontmattered Markdown files",
+        group: "team",
+        inputSchema: TeamExportMarkdownSchemaMcp,
+        outputSchema: TeamExportMarkdownOutputSchema,
+        annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
+        handler: () => ({
+          success: false,
+          error: "Team collaboration is not configured. Set TEAM_DB_PATH to enable."
+        })
+      },
+      {
+        name: "team_import_markdown",
+        title: "Team Import from Markdown",
+        description: "Import frontmattered Markdown files into the team journal",
+        group: "team",
+        inputSchema: TeamImportMarkdownSchemaMcp,
+        outputSchema: TeamImportMarkdownOutputSchema,
+        annotations: {
+          readOnlyHint: false,
+          idempotentHint: false,
+          openWorldHint: true
+        },
+        handler: () => ({
+          success: false,
+          error: "Team collaboration is not configured. Set TEAM_DB_PATH to enable."
+        })
+      }
+    ];
+  }
+  return [
+    {
+      name: "team_export_markdown",
+      title: "Team Export to Markdown",
+      description: "Export team journal entries as individual frontmattered Markdown files (.md). Includes author field in frontmatter. Files can be re-imported via team_import_markdown.",
+      group: "team",
+      inputSchema: TeamExportMarkdownSchemaMcp,
+      outputSchema: TeamExportMarkdownOutputSchema,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true
+      },
+      handler: async (params) => {
+        try {
+          const input = TeamExportMarkdownSchema.parse(params);
+          assertSafeDirectoryPath(input.output_dir);
+          await sendProgress(progress, 0, 3, "Fetching team entries...");
+          const limit = input.limit ?? 100;
+          let entries;
+          if (input.start_date || input.end_date) {
+            const startDate = input.start_date ?? DATE_MIN_SENTINEL;
+            const endDate = input.end_date ?? DATE_MAX_SENTINEL;
+            entries = teamDb.searchByDateRange(startDate, endDate, {
+              tags: input.tags,
+              limit
+            });
+          } else {
+            entries = teamDb.getRecentEntries(limit);
+          }
+          await sendProgress(
+            progress,
+            1,
+            3,
+            `Exporting ${String(entries.length)} team entries...`
+          );
+          const entryIds = entries.map((e) => e.id);
+          const authorMap = batchFetchAuthors(teamDb, entryIds);
+          const exportable = entries.map((e) => ({
+            id: e.id,
+            content: e.content,
+            entryType: e.entryType,
+            timestamp: e.timestamp,
+            tags: e.tags,
+            significance: e.significanceType ?? void 0,
+            author: authorMap.get(e.id) ?? void 0
+          }));
+          const result = await exportEntriesToMarkdown(
+            exportable,
+            input.output_dir,
+            teamDb
+          );
+          await sendProgress(progress, 3, 3, "Team export complete");
+          return result;
+        } catch (err) {
+          return formatHandlerError(err);
+        }
+      }
+    },
+    {
+      name: "team_import_markdown",
+      title: "Team Import from Markdown",
+      description: "Import frontmattered Markdown files (.md) into the team journal. Author is set from TEAM_AUTHOR env or git config. Use dry_run: true to preview without writing.",
+      group: "team",
+      inputSchema: TeamImportMarkdownSchemaMcp,
+      outputSchema: TeamImportMarkdownOutputSchema,
+      annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: true
+      },
+      handler: async (params) => {
+        try {
+          const input = TeamImportMarkdownSchema.parse(params);
+          assertSafeDirectoryPath(input.source_dir);
+          await sendProgress(progress, 0, 2, "Reading markdown files...");
+          const author = resolveAuthor();
+          const result = await importMarkdownEntries(
+            input.source_dir,
+            teamDb,
+            {
+              dry_run: input.dry_run,
+              limit: input.limit,
+              author
+            },
+            context.vectorManager
+          );
+          await sendProgress(progress, 2, 2, "Team import complete");
+          return result;
+        } catch (err) {
+          return formatHandlerError(err);
+        }
+      }
+    }
+  ];
+}
 function getTeamBackupTools(context) {
   const { teamDb } = context;
   return [
@@ -5295,6 +5971,7 @@ function getTeamTools(context) {
     ...getTeamAnalyticsTools(context),
     ...getTeamRelationshipTools(context),
     ...getTeamExportTools(context),
+    ...getTeamIoTools(context),
     ...getTeamBackupTools(context),
     ...getTeamVectorTools(context)
   ];
@@ -5324,8 +6001,10 @@ var METHOD_ALIASES = {
     link: "linkEntries",
     graph: "visualizeRelationships"
   },
-  export: {
-    dump: "exportEntries"
+  io: {
+    dump: "exportEntries",
+    md: "exportMarkdown",
+    importMd: "importMarkdown"
   },
   admin: {
     edit: "updateEntry",
@@ -5400,9 +6079,10 @@ var GROUP_EXAMPLES = {
     'mj.relationships.linkEntries({ from_entry_id: 1, to_entry_id: 2, relationship_type: "implements" })',
     "mj.relationships.visualizeRelationships({ entry_id: 1 })"
   ],
-  export: [
-    'mj.export.exportEntries({ format: "json" })',
-    'mj.export.exportEntries({ format: "markdown", limit: 50 })'
+  io: [
+    'mj.io.exportEntries({ format: "json" })',
+    'mj.io.exportMarkdown({ output_dir: "./export" })',
+    'mj.io.importMarkdown({ source_dir: "./import" })'
   ],
   admin: [
     'mj.admin.updateEntry({ entry_id: 1, content: "Updated content" })',
@@ -5493,7 +6173,7 @@ var GROUP_PREFIX_MAP = {
   search: "",
   analytics: "",
   relationships: "",
-  export: "",
+  io: "",
   admin: "",
   github: "",
   backup: "",
@@ -5596,7 +6276,7 @@ var JournalApi = class {
   search;
   analytics;
   relationships;
-  export;
+  io;
   admin;
   github;
   backup;
@@ -5617,7 +6297,7 @@ var JournalApi = class {
       "relationships",
       this.toolsByGroup.get("relationships") ?? []
     );
-    this.export = createGroupApi("export", this.toolsByGroup.get("export") ?? []);
+    this.io = createGroupApi("io", this.toolsByGroup.get("io") ?? []);
     this.admin = createGroupApi("admin", this.toolsByGroup.get("admin") ?? []);
     this.github = createGroupApi("github", this.toolsByGroup.get("github") ?? []);
     this.backup = createGroupApi("backup", this.toolsByGroup.get("backup") ?? []);
@@ -5649,7 +6329,9 @@ var JournalApi = class {
       search: this.search,
       analytics: this.analytics,
       relationships: this.relationships,
-      export: this.export,
+      io: this.io,
+      // Backward-compat alias — agents using mj.export.* still work
+      export: this.io,
       admin: this.admin,
       github: this.github,
       backup: this.backup,
@@ -5999,7 +6681,7 @@ var WorkerSandbox = class {
     const effectiveTimeout = timeoutMs ?? this.options.timeoutMs;
     const startTime = performance.now();
     const startRss = process.memoryUsage.rss();
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       const methodList = {};
       const topLevel = [];
       for (const [key, value] of Object.entries(apiBindings)) {
@@ -6055,7 +6737,7 @@ var WorkerSandbox = class {
           cpuTimeMs: result.metrics.cpuTimeMs,
           memoryUsedMb: Math.round((endRss - startRss) / 1024 / 1024)
         };
-        resolve(result);
+        resolve2(result);
       });
       worker.on("error", (err) => {
         clearTimeout(timeoutHandle);
@@ -6064,7 +6746,7 @@ var WorkerSandbox = class {
         const endRss = process.memoryUsage.rss();
         const errorMessage = err.message;
         const errorStack = err.stack;
-        resolve({
+        resolve2({
           success: false,
           error: errorMessage,
           stack: errorStack,
@@ -6081,7 +6763,7 @@ var WorkerSandbox = class {
         if (exitCode !== 0) {
           const endTime = performance.now();
           const endRss = process.memoryUsage.rss();
-          resolve({
+          resolve2({
             success: false,
             error: `Worker exited with code ${String(exitCode)} (likely timeout or OOM)`,
             metrics: {
@@ -6207,7 +6889,7 @@ function collectNonCodeModeTools(context) {
     ...getSearchTools(context),
     ...getAnalyticsTools(context),
     ...getRelationshipTools(context),
-    ...getExportTools(context),
+    ...getIoTools(context),
     ...getAdminTools(context),
     ...getGitHubTools(context),
     ...getBackupTools(context),
@@ -6221,7 +6903,7 @@ function getCodeModeTools(context) {
     {
       name: "mj_execute_code",
       title: "Execute Code (Code Mode)",
-      description: "Execute JavaScript in a sandboxed environment with access to all journal tools via the `mj.*` API. Enables multi-step workflows in a single call, reducing token usage by 70-90%. API groups: mj.core.*, mj.search.*, mj.analytics.*, mj.relationships.*, mj.export.*, mj.admin.*, mj.github.*, mj.backup.*, mj.team.*. Use mj.help() for method listing. Returns the last expression value.",
+      description: "Execute JavaScript in a sandboxed environment with access to all journal tools via the `mj.*` API. Enables multi-step workflows in a single call, reducing token usage by 70-90%. API groups: mj.core.*, mj.search.*, mj.analytics.*, mj.relationships.*, mj.io.*, mj.admin.*, mj.github.*, mj.backup.*, mj.team.*. Use mj.help() for method listing. Returns the last expression value.",
       group: "codemode",
       inputSchema: ExecuteCodeSchemaMcp,
       annotations: {
@@ -6645,7 +7327,7 @@ var TOOL_GROUPS = {
   search: ["search_entries", "search_by_date_range", "semantic_search", "get_vector_index_stats"],
   analytics: ["get_statistics", "get_cross_project_insights"],
   relationships: ["link_entries", "visualize_relationships"],
-  export: ["export_entries"],
+  io: ["export_entries", "export_markdown", "import_markdown"],
   admin: [
     "update_entry",
     "delete_entry",
@@ -6686,6 +7368,8 @@ var TOOL_GROUPS = {
     "team_link_entries",
     "team_visualize_relationships",
     "team_export_entries",
+    "team_export_markdown",
+    "team_import_markdown",
     "team_backup",
     "team_list_backups",
     "team_semantic_search",
@@ -6704,14 +7388,14 @@ var META_GROUPS = {
     "search",
     "analytics",
     "relationships",
-    "export",
+    "io",
     "admin",
     "github",
     "backup",
     "team",
     "codemode"
   ],
-  readonly: ["core", "search", "analytics", "relationships", "export"]
+  readonly: ["core", "search", "analytics", "relationships", "io"]
 };
 function getAllToolNames() {
   const allTools = [];
@@ -6737,8 +7421,12 @@ function getEnabledGroups(enabledTools) {
   }
   return groups;
 }
+var GROUP_ALIASES = { export: "io" };
+function resolveGroupAlias(name) {
+  return GROUP_ALIASES[name] ?? name;
+}
 function isGroup(name) {
-  return name in TOOL_GROUPS;
+  return resolveGroupAlias(name) in TOOL_GROUPS;
 }
 function isMetaGroup(name) {
   return name in META_GROUPS;
@@ -6761,7 +7449,8 @@ function parseToolFilter(filterString) {
           enabledTools = /* @__PURE__ */ new Set([...enabledTools, ...TOOL_GROUPS[group]]);
         }
       } else if (isGroup(name)) {
-        enabledTools = /* @__PURE__ */ new Set([...enabledTools, ...TOOL_GROUPS[name]]);
+        const resolved = resolveGroupAlias(name);
+        enabledTools = /* @__PURE__ */ new Set([...enabledTools, ...TOOL_GROUPS[resolved]]);
       } else {
         enabledTools.add(name);
       }
@@ -6772,7 +7461,8 @@ function parseToolFilter(filterString) {
       });
     } else if (isRemove) {
       if (isGroup(name)) {
-        for (const tool of TOOL_GROUPS[name]) {
+        const resolved = resolveGroupAlias(name);
+        for (const tool of TOOL_GROUPS[resolved]) {
           enabledTools.delete(tool);
         }
       } else {
@@ -6789,7 +7479,8 @@ function parseToolFilter(filterString) {
           enabledTools = /* @__PURE__ */ new Set([...enabledTools, ...TOOL_GROUPS[group]]);
         }
       } else if (isGroup(name)) {
-        enabledTools = /* @__PURE__ */ new Set([...enabledTools, ...TOOL_GROUPS[name]]);
+        const resolved = resolveGroupAlias(name);
+        enabledTools = /* @__PURE__ */ new Set([...enabledTools, ...TOOL_GROUPS[resolved]]);
       } else {
         enabledTools.add(name);
       }
@@ -6805,7 +7496,8 @@ function parseToolFilter(filterString) {
     for (const rule of rules) {
       if (rule.type === "exclude") {
         if (isGroup(rule.target)) {
-          for (const tool of TOOL_GROUPS[rule.target]) {
+          const resolved = resolveGroupAlias(rule.target);
+          for (const tool of TOOL_GROUPS[resolved]) {
             enabledTools.delete(tool);
           }
         } else {
@@ -6861,7 +7553,7 @@ var TOOL_GROUP_SCOPES = {
   search: SCOPES.READ,
   analytics: SCOPES.READ,
   relationships: SCOPES.READ,
-  export: SCOPES.READ,
+  io: SCOPES.READ,
   admin: SCOPES.ADMIN,
   github: SCOPES.WRITE,
   backup: SCOPES.ADMIN,
@@ -6914,6 +7606,8 @@ for (const [group, tools] of Object.entries(TOOL_GROUPS)) {
     }
   }
 }
+toolScopeMap.set("import_markdown", SCOPES.WRITE);
+toolScopeMap.set("team_import_markdown", SCOPES.WRITE);
 function getRequiredScope(toolName) {
   return toolScopeMap.get(toolName) ?? SCOPES.READ;
 }
@@ -7147,10 +7841,10 @@ function getToolIcon(group) {
       title: "Relationships",
       description: "Entry relationship management"
     },
-    export: {
-      iconUrl: "https://cdn.jsdelivr.net/npm/@mdi/svg@7.4.47/svg/export.svg",
-      title: "Export",
-      description: "Data export operations"
+    io: {
+      iconUrl: "https://cdn.jsdelivr.net/npm/@mdi/svg@7.4.47/svg/swap-horizontal.svg",
+      title: "IO",
+      description: "Import/export operations"
     },
     admin: {
       iconUrl: "https://cdn.jsdelivr.net/npm/@mdi/svg@7.4.47/svg/cog.svg",
@@ -7264,7 +7958,7 @@ function getAllToolDefinitions(context) {
     ...getSearchTools(context),
     ...getAnalyticsTools(context),
     ...getRelationshipTools(context),
-    ...getExportTools(context),
+    ...getIoTools(context),
     ...getAdminTools(context),
     ...getGitHubTools(context),
     ...getBackupTools(context),

package/dist/cli.js

@@ -1,7 +1,7 @@
-import { VERSION, createServer } from './chunk-6J4RPJ4I.js';
-import { DEFAULT_AUDIT_LOG_MAX_SIZE_BYTES } from './chunk-2BJHLTYP.js';
+import { VERSION, createServer } from './chunk-GW5DYUQJ.js';
+import { DEFAULT_AUDIT_LOG_MAX_SIZE_BYTES } from './chunk-JEGRDY6W.js';
 import './chunk-OKOVZ5QE.js';
-import { logger } from './chunk-ARLH46WS.js';
+import { logger } from './chunk-37BQOJDZ.js';
 import { Command } from 'commander';
 import * as fs from 'fs';
 

package/dist/github-integration-FOJ4U6I5.js

@@ -0,0 +1 @@
+export { GitHubIntegration } from './chunk-37BQOJDZ.js';

package/dist/index.d.ts

@@ -4,7 +4,7 @@
 /**
  * Tool group identifiers for Memory Journal
  */
-type ToolGroup = 'core' | 'search' | 'analytics' | 'relationships' | 'export' | 'admin' | 'github' | 'backup' | 'team' | 'codemode';
+type ToolGroup = 'core' | 'search' | 'analytics' | 'relationships' | 'io' | 'admin' | 'github' | 'backup' | 'team' | 'codemode';
 /**
  * Meta-group identifiers for common multi-group selections
  */
@@ -510,7 +510,7 @@ type SandboxMode = 'vm' | 'worker';
 /**
  * Tool group definitions mapping group names to tool names
  *
- * All 61 tools are categorized here for filtering support.
+ * All 65 tools are categorized here for filtering support.
  */
 declare const TOOL_GROUPS: Record<ToolGroup, string[]>;
 /**

package/dist/index.js

@@ -1,7 +1,7 @@
-export { VERSION, createServer } from './chunk-6J4RPJ4I.js';
-export { META_GROUPS, TOOL_GROUPS, calculateTokenSavings, filterTools, getAllToolNames, getFilterSummary, getToolFilterFromEnv, getToolGroup, isToolEnabled, parseToolFilter } from './chunk-2BJHLTYP.js';
+export { VERSION, createServer } from './chunk-GW5DYUQJ.js';
+export { META_GROUPS, TOOL_GROUPS, calculateTokenSavings, filterTools, getAllToolNames, getFilterSummary, getToolFilterFromEnv, getToolGroup, isToolEnabled, parseToolFilter } from './chunk-JEGRDY6W.js';
 import './chunk-OKOVZ5QE.js';
-export { logger } from './chunk-ARLH46WS.js';
+export { logger } from './chunk-37BQOJDZ.js';
 
 // src/types/index.ts
 var DEFAULT_CONFIG = {

package/dist/{tools-FFFGXIKN.js → tools-O44Q52RD.js}

@@ -1,3 +1,3 @@
-export { callTool, getGlobalAuditLogger, getTools, initializeAuditLogger } from './chunk-2BJHLTYP.js';
+export { callTool, getGlobalAuditLogger, getTools, initializeAuditLogger } from './chunk-JEGRDY6W.js';
 import './chunk-OKOVZ5QE.js';
-import './chunk-ARLH46WS.js';
+import './chunk-37BQOJDZ.js';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "memory-journal-mcp",
-    "version": "7.0.1",
+    "version": "7.1.0",
     "description": "Project context management for AI-assisted development - Persistent knowledge graphs and intelligent context recall across fragmented AI threads",
     "type": "module",
     "main": "dist/index.js",
@@ -82,7 +82,7 @@
         "globals": "^17.4.0",
         "tsup": "^8.5.1",
         "typescript": "^6.0.2",
-        "typescript-eslint": "^8.57.0",
+        "typescript-eslint": "^8.58.1",
         "vitest": "^4.1.3"
     },
     "overrides": {

package/dist/github-integration-PDRLXKGM.js

@@ -1 +0,0 @@
-export { GitHubIntegration } from './chunk-ARLH46WS.js';