memory-journal-mcp 7.0.1 → 7.2.0

package/dist/{chunk-2BJHLTYP.js → chunk-ORV7ZZOE.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, ValidationError, ResourceNotFoundError, assertSafeDirectoryPath, MemoryJournalMcpError, matchSuggestion, ConfigurationError } from './chunk-IWKLHSPU.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-2TFMXHIJ.js');
       const targetGithub = new GitHubIntegration2(entry[1].path);
       const repoInfo = await targetGithub.getRepoInfo();
       if (repoInfo.owner && repoInfo.repo) {
@@ -113,6 +114,7 @@ var SIGNIFICANCE_TYPES = [
   "release"
 ];
 var MAX_CONTENT_LENGTH = 5e4;
+var MAX_QUERY_LIMIT = 500;
 var DATE_MIN_SENTINEL = "1970-01-01";
 var DATE_MAX_SENTINEL = "2999-12-31";
 var DATE_FORMAT_REGEX = /^\d{4}-\d{2}-\d{2}$/;
@@ -214,7 +216,7 @@ var GetEntryByIdSchemaMcp = z.object({
   include_relationships: z.boolean().optional().default(true)
 });
 var GetRecentEntriesSchema = z.object({
-  limit: z.number().max(500).optional().default(5),
+  limit: z.number().min(1).max(MAX_QUERY_LIMIT).optional().default(5),
   is_personal: z.boolean().optional()
 });
 var GetRecentEntriesSchemaMcp = z.object({
@@ -451,7 +453,6 @@ function getCoreTools(context) {
 }
 
 // src/handlers/tools/search/helpers.ts
-var MAX_QUERY_LIMIT = 500;
 var DEDUP_KEY_LENGTH = 200;
 function calcPerDbLimit(limit, hasTeamDb) {
   return hasTeamDb ? Math.min(limit * 2, MAX_QUERY_LIMIT) : limit;
@@ -729,11 +730,23 @@ function getSearchTools(context) {
       handler: async (params) => {
         try {
           const input = SearchEntriesSchema.parse(params);
-          const query = input.query || "";
+          const query = input.query?.trim() || "";
           const mode = input.mode;
-          const { resolvedMode, isAuto } = resolveSearchMode(mode, query);
           const hasFilters = input.project_number !== void 0 || input.issue_number !== void 0 || input.pr_number !== void 0 || input.pr_status !== void 0 || input.workflow_run_id !== void 0 || input.is_personal !== void 0 || input.tags !== void 0 || input.entry_type !== void 0 || input.start_date !== void 0 || input.end_date !== void 0;
-          const effectiveMode = !query && !hasFilters ? "fts" : resolvedMode;
+          if (!query && !hasFilters) {
+            return {
+              ...formatHandlerError(
+                new ValidationError(
+                  "Search requires either a query string or at least one filter",
+                  { suggestion: "Provide a search query or use get_recent_entries instead" }
+                )
+              ),
+              entries: [],
+              count: 0
+            };
+          }
+          const { resolvedMode, isAuto } = resolveSearchMode(mode, query);
+          const effectiveMode = resolvedMode;
           const searchOptions = {
             limit: input.limit,
             isPersonal: input.is_personal,
@@ -1261,12 +1274,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")
 });
@@ -1308,10 +1332,10 @@ function getRelationshipTools(context) {
           const input = LinkEntriesSchema.parse(params);
           if (input.from_entry_id === input.to_entry_id) {
             return {
-              success: false,
-              error: "Cannot link an entry to itself",
-              code: "VALIDATION_ERROR",
-              category: "validation"
+              ...formatHandlerError(
+                new ValidationError("Cannot link an entry to itself")
+              ),
+              success: false
             };
           }
           const existingRelationships = db.getRelationships(input.from_entry_id);
@@ -1346,12 +1370,13 @@ function getRelationshipTools(context) {
             const isFkError = errMsg.includes("FOREIGN KEY constraint failed");
             if (isFkError) {
               return {
-                success: false,
-                error: `One or both entries not found (from: ${String(input.from_entry_id)}, to: ${String(input.to_entry_id)})`,
-                code: "RESOURCE_NOT_FOUND",
-                category: "resource",
-                suggestion: "Verify both entry IDs exist before linking",
-                recoverable: true
+                ...formatHandlerError(
+                  new ResourceNotFoundError(
+                    "Entry",
+                    `from: ${String(input.from_entry_id)}, to: ${String(input.to_entry_id)}`
+                  )
+                ),
+                success: false
               };
             }
           }
@@ -1463,15 +1488,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 +1582,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 +1945,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 +2054,107 @@ ${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);
+        }
+      }
     }
   ];
 }
@@ -1936,6 +2448,8 @@ var GitHubIssueOutputSchema = z.object({
 }).extend(ErrorFieldsMixin.shape);
 var GitHubIssueDetailsOutputSchema = GitHubIssueOutputSchema.extend({
   body: z.string().nullable(),
+  bodyTruncated: z.boolean().optional(),
+  bodyFullLength: z.number().optional(),
   labels: z.array(z.string()),
   assignees: z.array(z.string()),
   createdAt: z.string(),
@@ -1956,6 +2470,14 @@ var GitHubIssuesListOutputSchema = z.object({
 }).extend(ErrorFieldsMixin.shape);
 var GitHubIssueResultOutputSchema = z.object({
   issue: GitHubIssueDetailsOutputSchema.optional(),
+  comments: z.array(
+    z.object({
+      author: z.string(),
+      body: z.string(),
+      createdAt: z.string()
+    })
+  ).optional(),
+  commentCount: z.number().optional(),
   owner: z.string().optional(),
   repo: z.string().optional(),
   detectedOwner: z.string().nullable().optional(),
@@ -1972,6 +2494,8 @@ var GitHubPullRequestOutputSchema = z.object({
 }).extend(ErrorFieldsMixin.shape);
 var GitHubPRDetailsOutputSchema = GitHubPullRequestOutputSchema.extend({
   body: z.string().nullable(),
+  bodyTruncated: z.boolean().optional(),
+  bodyFullLength: z.number().optional(),
   draft: z.boolean(),
   headBranch: z.string(),
   baseBranch: z.string(),
@@ -2036,7 +2560,9 @@ var StatusOptionOutputSchema = z.object({
 var KanbanColumnOutputSchema = z.object({
   status: z.string(),
   statusOptionId: z.string(),
-  items: z.array(KanbanItemOutputSchema)
+  items: z.array(KanbanItemOutputSchema).optional(),
+  itemCount: z.number().optional(),
+  truncated: z.boolean().optional()
 });
 var KanbanBoardOutputSchema = z.object({
   projectId: z.string().optional(),
@@ -2046,6 +2572,14 @@ var KanbanBoardOutputSchema = z.object({
   statusOptions: z.array(StatusOptionOutputSchema).optional(),
   columns: z.array(KanbanColumnOutputSchema).optional(),
   totalItems: z.number().optional(),
+  itemDirectory: z.array(
+    z.object({
+      id: z.string(),
+      title: z.string(),
+      status: z.string().nullable()
+    })
+  ).optional(),
+  summaryOnly: z.boolean().optional(),
   owner: z.string().optional(),
   detectedOwner: z.string().nullable().optional(),
   detectedRepo: z.string().nullable().optional(),
@@ -2055,16 +2589,19 @@ var KanbanBoardOutputSchema = z.object({
   instruction: z.string().optional()
 }).extend(ErrorFieldsMixin.shape);
 var MoveKanbanItemOutputSchema = z.object({
-  success: z.boolean().optional(),
   itemId: z.string().optional(),
   newStatus: z.string().optional(),
   projectNumber: z.number().optional(),
-  message: z.string().optional(),
-  error: z.string().optional(),
-  requiresUserInput: z.boolean().optional(),
-  hint: z.string().optional(),
   availableStatuses: z.array(z.string()).optional()
 }).extend(ErrorFieldsMixin.shape);
+var AddKanbanItemOutputSchema = z.object({
+  itemId: z.string().optional(),
+  projectNumber: z.number().optional()
+}).extend(ErrorFieldsMixin.shape);
+var DeleteKanbanItemOutputSchema = z.object({
+  itemId: z.string().optional(),
+  projectNumber: z.number().optional()
+}).extend(ErrorFieldsMixin.shape);
 var CreateGitHubIssueWithEntryOutputSchema = z.object({
   success: z.boolean().optional(),
   issue: z.object({
@@ -2355,7 +2892,7 @@ function getGitHubReadTools(context) {
             owner: z.string().optional(),
             repo: z.string().optional(),
             state: z.enum(["open", "closed", "all"]).optional().default("open"),
-            limit: z.number().optional().default(20)
+            limit: z.number().max(MAX_QUERY_LIMIT).optional().default(20)
           }).parse(params);
           const resolved = await resolveOwnerRepo(
             context,
@@ -2405,7 +2942,7 @@ function getGitHubReadTools(context) {
             owner: z.string().optional(),
             repo: z.string().optional(),
             state: z.enum(["open", "closed", "all"]).optional().default("open"),
-            limit: z.number().optional().default(20)
+            limit: z.number().max(MAX_QUERY_LIMIT).optional().default(20)
           }).parse(params);
           const resolved = await resolveOwnerRepo(
             context,
@@ -2440,7 +2977,11 @@ function getGitHubReadTools(context) {
       inputSchema: z.object({
         issue_number: z.number(),
         owner: z.string().optional().describe("LEAVE EMPTY to auto-detect from git"),
-        repo: z.string().optional().describe("LEAVE EMPTY to auto-detect from git")
+        repo: z.string().optional().describe("LEAVE EMPTY to auto-detect from git"),
+        truncate_body: relaxedNumber().optional().default(800).describe(
+          "Max characters for body text (0 = full body, default 800). Reduces token usage."
+        ),
+        include_comments: z.boolean().optional().default(false).describe("Include issue comments (default false). Each comment adds tokens.")
       }),
       outputSchema: GitHubIssueResultOutputSchema,
       annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
@@ -2449,7 +2990,9 @@ function getGitHubReadTools(context) {
           const input = z.object({
             issue_number: z.number(),
             owner: z.string().optional(),
-            repo: z.string().optional()
+            repo: z.string().optional(),
+            truncate_body: z.number().optional().default(800),
+            include_comments: z.boolean().optional().default(false)
           }).parse(params);
           const resolved = await resolveOwnerRepo(context, input, "is this issue from");
           if ("error" in resolved) return resolved.response;
@@ -2472,8 +3015,30 @@ function getGitHubReadTools(context) {
               detectedRepo: resolved.detectedRepo
             };
           }
+          const truncateBody = input.truncate_body;
+          let bodyTruncated = false;
+          let bodyFullLength;
+          if (truncateBody > 0 && issue.body && issue.body.length > truncateBody) {
+            bodyFullLength = issue.body.length;
+            const remaining = issue.body.length - truncateBody;
+            issue.body = issue.body.slice(0, truncateBody) + `
+[Truncated. Re-run with truncate_body: 0 to view remaining ${String(remaining)} chars]`;
+            bodyTruncated = true;
+          }
+          let comments;
+          if (input.include_comments) {
+            comments = await resolved.github.getIssueComments(
+              resolved.owner,
+              resolved.repo,
+              input.issue_number
+            );
+          }
           return {
-            issue,
+            issue: {
+              ...issue,
+              ...bodyTruncated ? { bodyTruncated: true, bodyFullLength } : {}
+            },
+            ...comments ? { comments, commentCount: comments.length } : {},
             owner: resolved.owner,
             repo: resolved.repo,
             detectedOwner: resolved.detectedOwner,
@@ -2492,7 +3057,10 @@ function getGitHubReadTools(context) {
       inputSchema: z.object({
         pr_number: z.number(),
         owner: z.string().optional().describe("LEAVE EMPTY to auto-detect from git"),
-        repo: z.string().optional().describe("LEAVE EMPTY to auto-detect from git")
+        repo: z.string().optional().describe("LEAVE EMPTY to auto-detect from git"),
+        truncate_body: relaxedNumber().optional().default(800).describe(
+          "Max characters for body text (0 = full body, default 800). Reduces token usage."
+        )
       }),
       outputSchema: GitHubPRResultOutputSchema,
       annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
@@ -2501,7 +3069,8 @@ function getGitHubReadTools(context) {
           const input = z.object({
             pr_number: z.number(),
             owner: z.string().optional(),
-            repo: z.string().optional()
+            repo: z.string().optional(),
+            truncate_body: z.number().optional().default(800)
           }).parse(params);
           const resolved = await resolveOwnerRepo(context, input, "is this PR from");
           if ("error" in resolved) return resolved.response;
@@ -2524,8 +3093,21 @@ function getGitHubReadTools(context) {
               detectedRepo: resolved.detectedRepo
             };
           }
+          const truncateBody = input.truncate_body;
+          let bodyTruncated = false;
+          let bodyFullLength;
+          if (truncateBody > 0 && pullRequest.body && pullRequest.body.length > truncateBody) {
+            bodyFullLength = pullRequest.body.length;
+            const remaining = pullRequest.body.length - truncateBody;
+            pullRequest.body = pullRequest.body.slice(0, truncateBody) + `
+[Truncated. Re-run with truncate_body: 0 to view remaining ${String(remaining)} chars]`;
+            bodyTruncated = true;
+          }
           return {
-            pullRequest,
+            pullRequest: {
+              ...pullRequest,
+              ...bodyTruncated ? { bodyTruncated: true, bodyFullLength } : {}
+            },
             owner: resolved.owner,
             repo: resolved.repo,
             detectedOwner: resolved.detectedOwner,
@@ -2593,7 +3175,13 @@ function getKanbanTools(context) {
       inputSchema: z.object({
         project_number: z.number().optional().describe("GitHub Project number (optional if repo is registered)"),
         owner: z.string().optional().describe("Project owner - LEAVE EMPTY to auto-detect"),
-        repo: z.string().optional().describe("Repository name - LEAVE EMPTY to auto-detect")
+        repo: z.string().optional().describe("Repository name - LEAVE EMPTY to auto-detect"),
+        summary_only: z.boolean().optional().default(false).describe(
+          "Return column summaries only (name + itemCount), omitting individual items. Saves ~80% tokens."
+        ),
+        item_limit: relaxedNumber().optional().default(25).describe(
+          "Maximum items per column (default 25, max 100). Set to 0 for summary_only behavior."
+        )
       }),
       outputSchema: KanbanBoardOutputSchema,
       annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
@@ -2602,7 +3190,9 @@ function getKanbanTools(context) {
           const input = z.object({
             project_number: z.number().optional(),
             owner: z.string().optional(),
-            repo: z.string().optional()
+            repo: z.string().optional(),
+            summary_only: z.boolean().optional().default(false),
+            item_limit: z.number().max(100).optional().default(25)
           }).parse(params);
           const resolved = await resolveOwner(context, input.owner);
           if ("error" in resolved) return resolved.response;
@@ -2641,7 +3231,44 @@ function getKanbanTools(context) {
               recoverable: true
             };
           }
-          return board;
+          const summaryOnly = input.summary_only || input.item_limit === 0;
+          if (summaryOnly) {
+            const summaryColumns = board.columns.map((col) => ({
+              status: col.status,
+              statusOptionId: col.statusOptionId,
+              items: [],
+              itemCount: col.items.length
+            }));
+            const itemDirectory = board.columns.flatMap(
+              (col) => col.items.map((item) => ({
+                id: item.id,
+                title: item.title,
+                status: item.status
+              }))
+            );
+            return {
+              ...board,
+              columns: summaryColumns,
+              summaryOnly: true,
+              itemDirectory
+            };
+          }
+          const itemLimit = input.item_limit;
+          const truncatedColumns = board.columns.map((col) => {
+            if (col.items.length <= itemLimit) {
+              return { ...col, itemCount: col.items.length };
+            }
+            return {
+              ...col,
+              items: col.items.slice(0, itemLimit),
+              itemCount: col.items.length,
+              truncated: true
+            };
+          });
+          return {
+            ...board,
+            columns: truncatedColumns
+          };
         } catch (err) {
           return formatHandlerError(err);
         }
@@ -2734,6 +3361,155 @@ function getKanbanTools(context) {
           return formatHandlerError(err);
         }
       }
+    },
+    {
+      name: "add_kanban_item",
+      title: "Add Kanban Item",
+      description: "Add an existing GitHub Issue or Pull Request to a Kanban board (GitHub Project v2). Returns the project item ID on success.",
+      group: "github",
+      inputSchema: z.object({
+        project_number: z.number().optional().describe("GitHub Project number (optional if repo is registered)"),
+        issue_number: z.number().describe("The number of the issue or PR to add"),
+        owner: z.string().optional().describe("Repository owner - LEAVE EMPTY to auto-detect"),
+        repo: z.string().optional().describe("Repository name - LEAVE EMPTY to auto-detect")
+      }),
+      outputSchema: AddKanbanItemOutputSchema,
+      annotations: { readOnlyHint: false, idempotentHint: true, openWorldHint: true },
+      handler: async (params) => {
+        try {
+          const input = z.object({
+            project_number: z.number().optional(),
+            issue_number: z.number(),
+            owner: z.string().optional(),
+            repo: z.string().optional()
+          }).parse(params);
+          const resolved = await resolveOwnerRepo(context, input);
+          if ("error" in resolved) return resolved.response;
+          const projectNum = resolveProjectNumber(
+            context,
+            resolved.repo,
+            input.project_number
+          );
+          if (projectNum === void 0) {
+            return {
+              success: false,
+              error: "project_number is required and could not be resolved from registry. Please supply it explicitly.",
+              code: "VALIDATION_ERROR",
+              category: "validation",
+              recoverable: true
+            };
+          }
+          const issueDetails = await resolved.github.getIssue(
+            resolved.owner,
+            resolved.repo,
+            input.issue_number
+          );
+          if (!issueDetails?.nodeId) {
+            return {
+              success: false,
+              error: `Issue or PR #${String(input.issue_number)} not found or lacks a nodeId`,
+              code: "RESOURCE_NOT_FOUND",
+              category: "resource",
+              recoverable: true
+            };
+          }
+          const board = await resolved.github.getProjectKanban(
+            resolved.owner,
+            projectNum,
+            resolved.repo
+          );
+          if (!board) {
+            return {
+              success: false,
+              error: `Project #${String(projectNum)} not found`,
+              code: "RESOURCE_NOT_FOUND",
+              category: "resource",
+              recoverable: true
+            };
+          }
+          const result = await resolved.github.addProjectItem(
+            board.projectId,
+            issueDetails.nodeId
+          );
+          return {
+            success: result.success,
+            itemId: result.itemId,
+            projectNumber: projectNum,
+            message: result.success ? `Added Issue/PR #${String(input.issue_number)} to Project #${projectNum}` : void 0,
+            error: result.error
+          };
+        } catch (err) {
+          return formatHandlerError(err);
+        }
+      }
+    },
+    {
+      name: "delete_kanban_item",
+      title: "Delete Kanban Item",
+      description: "Remove an item from a GitHub Kanban board cleanly. This untethers it from the project but does NOT close or delete the underlying Issue/PR.",
+      group: "github",
+      inputSchema: z.object({
+        project_number: z.number().optional().describe("GitHub Project number (optional if repo is registered)"),
+        item_id: z.string().describe("The project item ID to remove (from get_kanban_board)"),
+        owner: z.string().optional().describe("Project owner - LEAVE EMPTY to auto-detect"),
+        repo: z.string().optional().describe("Repository name - LEAVE EMPTY to auto-detect")
+      }),
+      outputSchema: DeleteKanbanItemOutputSchema,
+      annotations: { readOnlyHint: false, idempotentHint: false, openWorldHint: true },
+      handler: async (params) => {
+        try {
+          const input = z.object({
+            project_number: z.number().optional(),
+            item_id: z.string(),
+            owner: z.string().optional(),
+            repo: z.string().optional()
+          }).parse(params);
+          const resolved = await resolveOwner(context, input.owner);
+          if ("error" in resolved) return resolved.response;
+          const effectiveRepo = input.repo ?? resolved.repo;
+          const projectNum = resolveProjectNumber(
+            context,
+            effectiveRepo,
+            input.project_number
+          );
+          if (projectNum === void 0) {
+            return {
+              success: false,
+              error: "project_number is required and could not be resolved from registry. Please supply it explicitly.",
+              code: "VALIDATION_ERROR",
+              category: "validation",
+              recoverable: true
+            };
+          }
+          const board = await resolved.github.getProjectKanban(
+            resolved.owner,
+            projectNum,
+            effectiveRepo
+          );
+          if (!board) {
+            return {
+              success: false,
+              error: `Project #${String(projectNum)} not found`,
+              code: "RESOURCE_NOT_FOUND",
+              category: "resource",
+              recoverable: true
+            };
+          }
+          const result = await resolved.github.deleteProjectItem(
+            board.projectId,
+            input.item_id
+          );
+          return {
+            success: result.success,
+            itemId: input.item_id,
+            projectNumber: projectNum,
+            message: result.success ? `Deleted item ${input.item_id} from Project #${projectNum}` : void 0,
+            error: result.error
+          };
+        } catch (err) {
+          return formatHandlerError(err);
+        }
+      }
     }
   ];
 }
@@ -2791,7 +3567,11 @@ function getGitHubIssueTools(context) {
           if (!issue) {
             return {
               success: false,
-              error: "Failed to create GitHub issue. Check GITHUB_TOKEN permissions."
+              error: "Failed to create GitHub issue. Check GITHUB_TOKEN permissions.",
+              code: "API_ERROR",
+              category: "api",
+              suggestion: "Verify GitHub token has write access to issues.",
+              recoverable: true
             };
           }
           const projectNumber = resolveProjectNumber(
@@ -2950,13 +3730,21 @@ Description: ${input.body.slice(0, 200)}${input.body.length > 200 ? "..." : ""}`
           if (!issueDetails) {
             return {
               success: false,
-              error: `Issue #${String(input.issue_number)} not found`
+              error: `Issue #${String(input.issue_number)} not found`,
+              code: "RESOURCE_NOT_FOUND",
+              category: "resource",
+              suggestion: "Verify the issue number exists in this repository.",
+              recoverable: true
             };
           }
           if (issueDetails.state === "CLOSED") {
             return {
-              success: false,
-              error: `Issue #${String(input.issue_number)} is already closed`
+              ...formatHandlerError(
+                new ValidationError(
+                  `Issue #${String(input.issue_number)} is already closed`
+                )
+              ),
+              success: false
             };
           }
           const result = await resolved.github.closeIssue(
@@ -2968,7 +3756,11 @@ Description: ${input.body.slice(0, 200)}${input.body.length > 200 ? "..." : ""}`
           if (!result) {
             return {
               success: false,
-              error: "Failed to close GitHub issue. Check GITHUB_TOKEN permissions."
+              error: "Failed to close GitHub issue. Check GITHUB_TOKEN permissions.",
+              code: "API_ERROR",
+              category: "api",
+              suggestion: "Verify GitHub token has write access to issues.",
+              recoverable: true
             };
           }
           let kanbanResult;
@@ -3127,10 +3919,12 @@ function isResourceError(result) {
 }
 var DEFAULT_BRIEFING_CONFIG = {
   entryCount: 3,
+  summaryCount: 1,
   includeTeam: false,
   issueCount: 0,
   prCount: 0,
   prStatusBreakdown: false,
+  milestoneCount: 3,
   workflowCount: 0,
   workflowStatusBreakdown: false,
   copilotReviews: false
@@ -3870,7 +4664,7 @@ var TeamCreateEntrySchemaMcp = z.object({
   author: z.string().optional()
 });
 var TeamGetRecentSchema = z.object({
-  limit: z.number().max(500).optional().default(10)
+  limit: z.number().min(1).max(500).optional().default(10)
 });
 var TeamGetRecentSchemaMcp = z.object({
   limit: relaxedNumber().optional().default(10)
@@ -5015,6 +5809,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 +6262,7 @@ function getTeamTools(context) {
     ...getTeamAnalyticsTools(context),
     ...getTeamRelationshipTools(context),
     ...getTeamExportTools(context),
+    ...getTeamIoTools(context),
     ...getTeamBackupTools(context),
     ...getTeamVectorTools(context)
   ];
@@ -5324,8 +6292,10 @@ var METHOD_ALIASES = {
     link: "linkEntries",
     graph: "visualizeRelationships"
   },
-  export: {
-    dump: "exportEntries"
+  io: {
+    dump: "exportEntries",
+    md: "exportMarkdown",
+    importMd: "importMarkdown"
   },
   admin: {
     edit: "updateEntry",
@@ -5342,6 +6312,8 @@ var METHOD_ALIASES = {
     context: "getGithubContext",
     kanban: "getKanbanBoard",
     moveKanban: "moveKanbanItem",
+    addKanban: "addKanbanItem",
+    deleteKanban: "deleteKanbanItem",
     milestones: "getGithubMilestones",
     milestone: "getGithubMilestone",
     createMilestone: "createGithubMilestone",
@@ -5400,9 +6372,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" })',
@@ -5415,6 +6388,7 @@ var GROUP_EXAMPLES = {
     'mj.github.getGithubIssues({ state: "open" })',
     'mj.github.getGithubPrs({ state: "open" })',
     "mj.github.getKanbanBoard({ project_number: 1 })",
+    "mj.github.addKanbanItem({ project_number: 1, issue_number: 123 })",
     "mj.github.getGithubMilestones()",
     "mj.github.getRepoInsights()"
   ],
@@ -5463,7 +6437,9 @@ var POSITIONAL_PARAM_MAP = {
   getGithubIssue: "issue_number",
   getGithubPr: "pr_number",
   getKanbanBoard: "project_number",
-  moveKanbanItem: ["item_id", "status"],
+  moveKanbanItem: ["item_id", "target_status"],
+  addKanbanItem: "issue_number",
+  deleteKanbanItem: "item_id",
   getGithubMilestone: "milestone_number",
   createGithubMilestone: "title",
   updateGithubMilestone: "milestone_number",
@@ -5493,7 +6469,7 @@ var GROUP_PREFIX_MAP = {
   search: "",
   analytics: "",
   relationships: "",
-  export: "",
+  io: "",
   admin: "",
   github: "",
   backup: "",
@@ -5596,7 +6572,7 @@ var JournalApi = class {
   search;
   analytics;
   relationships;
-  export;
+  io;
   admin;
   github;
   backup;
@@ -5617,7 +6593,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 +6625,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,
@@ -5695,8 +6673,8 @@ var DEFAULT_SECURITY_CONFIG = {
   maxCodeLength: 50 * 1024,
   // 50KB
   maxExecutionsPerMinute: 60,
-  maxResultSize: 10 * 1024 * 1024,
-  // 10MB
+  maxResultSize: 100 * 1024,
+  // 100KB — context window protection (configurable via CODE_MODE_MAX_RESULT_SIZE)
   blockedPatterns: [
     /\brequire\s*\(/,
     // No require()
@@ -5811,9 +6789,12 @@ var CodeModeSecurityManager = class {
     const errors = [];
     try {
       const serialized = JSON.stringify(result);
-      if (Buffer.byteLength(serialized, "utf-8") > this.config.maxResultSize) {
+      const actualBytes = Buffer.byteLength(serialized, "utf-8");
+      if (actualBytes > this.config.maxResultSize) {
+        const actualKb = Math.ceil(actualBytes / 1024);
+        const limitKb = Math.ceil(this.config.maxResultSize / 1024);
         errors.push(
-          `Result exceeds maximum size of ${String(this.config.maxResultSize)} bytes`
+          `Result exceeds maximum size of ${String(limitKb)} KB (${String(actualKb)} KB returned). Extract specific fields or aggregate data before returning. Example: instead of \`return await mj.github.getKanbanBoard(5)\`, use \`const b = await mj.github.getKanbanBoard(5); return { columns: b.columns?.length ?? 0, totalItems: b.totalItems }\``
         );
       }
     } catch (error) {
@@ -5999,7 +6980,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 +7036,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 +7045,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 +7062,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: {
@@ -6189,7 +7170,12 @@ var ExecuteCodeSchemaMcp = z.object({
 var securityManager = null;
 var sandboxPool = null;
 function getSecurityManager() {
-  securityManager ??= new CodeModeSecurityManager();
+  if (!securityManager) {
+    const envMaxSize = process.env["CODE_MODE_MAX_RESULT_SIZE"];
+    const parsedMaxSize = envMaxSize && /^\d+$/.test(envMaxSize) ? parseInt(envMaxSize, 10) : void 0;
+    const overrides = parsedMaxSize !== void 0 && Number.isFinite(parsedMaxSize) && Number.isInteger(parsedMaxSize) && parsedMaxSize > 0 ? { maxResultSize: parsedMaxSize } : void 0;
+    securityManager = new CodeModeSecurityManager(overrides);
+  }
   return securityManager;
 }
 function getSandboxPool() {
@@ -6207,7 +7193,7 @@ function collectNonCodeModeTools(context) {
     ...getSearchTools(context),
     ...getAnalyticsTools(context),
     ...getRelationshipTools(context),
-    ...getExportTools(context),
+    ...getIoTools(context),
     ...getAdminTools(context),
     ...getGitHubTools(context),
     ...getBackupTools(context),
@@ -6221,7 +7207,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 +7631,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",
@@ -6661,6 +7647,8 @@ var TOOL_GROUPS = {
     "get_github_context",
     "get_kanban_board",
     "move_kanban_item",
+    "add_kanban_item",
+    "delete_kanban_item",
     "create_github_issue_with_entry",
     "close_github_issue_with_entry",
     "get_github_milestones",
@@ -6686,6 +7674,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 +7694,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 +7727,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 +7755,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 +7767,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 +7785,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 +7802,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 +7859,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 +7912,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 +8147,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 +8264,7 @@ function getAllToolDefinitions(context) {
     ...getSearchTools(context),
     ...getAnalyticsTools(context),
     ...getRelationshipTools(context),
-    ...getExportTools(context),
+    ...getIoTools(context),
     ...getAdminTools(context),
     ...getGitHubTools(context),
     ...getBackupTools(context),