memory-journal-mcp 9.0.0 → 9.1.0

package/dist/chunk-SGJU2DHU.js

@@ -0,0 +1,2102 @@
+import { resolveProjectContext } from './chunk-D2FY6XS5.js';
+import { createRequire } from 'module';
+
+var require2 = createRequire(import.meta.url);
+var pkg = require2("../package.json");
+var VERSION = pkg.version;
+
+// src/codemode/constants/method-aliases.ts
+function mapToTarget(keys, target) {
+  const out = {};
+  for (const k of keys) out[k] = target;
+  return out;
+}
+var SHARED_PROJECT_ALIASES = {
+  ...mapToTarget(
+    [
+      "getProject",
+      "getProjectByName",
+      "get_project_by_name",
+      "getProjectByNumber",
+      "get_project_by_number",
+      "findProject",
+      "find_project",
+      "mj_get_project",
+      "mjGetProject"
+    ],
+    "getProject"
+  ),
+  ...mapToTarget(
+    ["listProjects", "list_projects", "mj_list_projects", "mjListProjects", "projects"],
+    "listProjects"
+  )
+};
+var SHARED_HEALTH_ALIASES = mapToTarget(
+  [
+    "serverInfo",
+    "server_info",
+    "serverHealth",
+    "server_health",
+    "health",
+    "status",
+    "adapters",
+    "list_adapters",
+    "listAdapters",
+    "get_adapters",
+    "getAdapters"
+  ],
+  "getStatistics"
+);
+var SHARED_GREP_SEARCH_ALIASES = mapToTarget(
+  [
+    "grep",
+    "grepSearch",
+    "grep_search",
+    "fileSearch",
+    "file_search",
+    "findInFiles",
+    "find_in_files",
+    "find",
+    "search",
+    "query",
+    "queryEntries",
+    "query_entries"
+  ],
+  "searchEntries"
+);
+var METHOD_ALIASES = {
+  core: {
+    ...mapToTarget(
+      [
+        "create",
+        "add",
+        "newEntry",
+        "addEntry",
+        "insert",
+        "write",
+        "log",
+        "record",
+        "note",
+        "save",
+        "execute",
+        "executeCode",
+        "execute_code",
+        "quick",
+        "createEntryMinimal",
+        "appendInsight",
+        "writeQuery",
+        "updateMemory",
+        "update_memory",
+        "createMemory",
+        "create_memory",
+        "addMemory",
+        "add_memory",
+        "saveMemory",
+        "save_memory",
+        "recordMemory",
+        "record_memory",
+        "setMemory",
+        "set_memory",
+        "updateJournal",
+        "update_journal",
+        "sessionSummary",
+        "append",
+        "appendEntry",
+        "append_entry",
+        "logJournal",
+        "log_journal",
+        "logEntry",
+        "log_entry",
+        "insertJournal",
+        "insert_journal",
+        "addJournal",
+        "add_journal",
+        "saveJournalEntry",
+        "save_journal_entry",
+        "createJournalEntry",
+        "create_journal_entry",
+        "create_entry",
+        "mj_create_entry",
+        "mjCreateEntry",
+        "add_entry",
+        "mj_add_entry",
+        "mjAddEntry"
+      ],
+      "createEntry"
+    ),
+    ...mapToTarget(
+      ["get", "getEntry", "fetch", "read", "get_entry_by_id", "viewFile", "view_file", "readFile", "read_file"],
+      "getEntryById"
+    ),
+    ...mapToTarget(
+      [
+        "recent",
+        "getRecent",
+        "list",
+        "entries",
+        "all",
+        "latest",
+        "get_recent_entries",
+        "select",
+        "sql",
+        "executeSql",
+        "execSql",
+        "execute_sql",
+        "exec_sql",
+        "fetchEntries",
+        "getAll",
+        "listDir",
+        "list_dir"
+      ],
+      "getRecentEntries"
+    ),
+    ...mapToTarget(["tags", "getTags", "get_tags", "list_tags"], "listTags"),
+    ...mapToTarget(
+      ["read_resource", "readResource", "memory_read_resource", "memoryReadResource", "get_resource", "getResource"],
+      "readResource"
+    ),
+    ...mapToTarget(["history", "revisions", "get_entry_history"], "getEntryHistory"),
+    ...mapToTarget(["schema", "getSchema", "get_schema", "database", "getDatabase", "get_database", "getDb", "get_db"], "getStatistics"),
+    ...SHARED_PROJECT_ALIASES,
+    ...SHARED_HEALTH_ALIASES,
+    ...SHARED_GREP_SEARCH_ALIASES,
+    listEntries: "searchEntries",
+    create_entry_minimal: "createEntryMinimal",
+    search_audit_log: "searchAuditLog",
+    update: "updateEntry",
+    delete: "deleteEntry",
+    updateEntry: "updateEntry",
+    deleteEntry: "deleteEntry",
+    update_entry: "updateEntry",
+    delete_entry: "deleteEntry"
+  },
+  search: {
+    ...SHARED_GREP_SEARCH_ALIASES,
+    ...mapToTarget(
+      [
+        "lookup",
+        "findEntries",
+        "find_entries",
+        "listEntries",
+        "list_entries",
+        "entries",
+        "readQuery",
+        "read_query",
+        "select",
+        "sql",
+        "executeSql",
+        "execSql",
+        "sqlQuery",
+        "querySql",
+        "execute_sql",
+        "exec_sql",
+        "search_entries"
+      ],
+      "searchEntries"
+    ),
+    byDate: "searchByDateRange",
+    similar: "semanticSearch",
+    stats: "getVectorIndexStats",
+    deleted: "listDeletedEntries",
+    trash: "listDeletedEntries",
+    crossSearch: "crossTeamSearch",
+    search_by_date_range: "searchByDateRange",
+    semantic_search: "semanticSearch",
+    get_vector_index_stats: "getVectorIndexStats",
+    list_deleted_entries: "listDeletedEntries",
+    cross_team_search: "crossTeamSearch"
+  },
+  analytics: {
+    ...mapToTarget(
+      [
+        "stats",
+        "getStats",
+        "statistics",
+        "schema",
+        "getSchema",
+        "get_schema",
+        "tables",
+        "getTables",
+        "get_tables",
+        "describe",
+        "databaseInfo",
+        "getDatabaseInfo",
+        "get_database_info",
+        "database",
+        "getDatabase",
+        "get_database",
+        "getDb",
+        "get_db",
+        "db",
+        "dbStats",
+        "getDbStats",
+        "get_db_stats",
+        "dbInfo",
+        "getDbInfo",
+        "get_db_info",
+        "get_statistics"
+      ],
+      "getStatistics"
+    ),
+    ...SHARED_HEALTH_ALIASES,
+    ...mapToTarget(
+      ["insights", "getInsights", "getProjects", "listProjects", "list_projects", "projects", "get_cross_project_insights"],
+      "getCrossProjectInsights"
+    )
+  },
+  relationships: {
+    link: "linkEntries",
+    graph: "visualizeRelationships",
+    link_entries: "linkEntries",
+    visualize_relationships: "visualizeRelationships"
+  },
+  io: {
+    dump: "exportEntries",
+    md: "exportMarkdown",
+    importMd: "importMarkdown",
+    importNotion: "importExternal",
+    importObsidian: "importExternal",
+    export_entries: "exportEntries",
+    export_markdown: "exportMarkdown",
+    import_markdown: "importMarkdown",
+    import_external: "importExternal"
+  },
+  admin: {
+    ...mapToTarget(
+      [
+        "edit",
+        "update",
+        "editEntry",
+        "modifyEntry",
+        "modify",
+        "updateMemory",
+        "update_memory",
+        "setMemory",
+        "set_memory",
+        "updateJournal",
+        "update_journal",
+        "saveMemory",
+        "save_memory",
+        "update_entry"
+      ],
+      "updateEntry"
+    ),
+    ...mapToTarget(["remove", "delete", "removeEntry", "delete_entry"], "deleteEntry"),
+    ...mapToTarget(["restore", "restoreEntry", "restore_entry"], "restoreEntry"),
+    ...mapToTarget(
+      ["batchCreate", "bulkCreate", "createEntries", "batchCreateEntry", "batch_create_entries"],
+      "batchCreateEntries"
+    ),
+    ...mapToTarget(["batchUpdate", "bulkUpdate", "updateEntries", "batch_update_entries"], "batchUpdateEntries"),
+    ...mapToTarget(["batchDelete", "bulkDelete", "deleteEntries", "batch_delete_entries"], "batchDeleteEntries"),
+    ...mapToTarget(["config", "configure", "update_configuration"], "updateConfiguration"),
+    ...mapToTarget(["auditLog", "audit", "search_audit_log"], "searchAuditLog"),
+    ...SHARED_PROJECT_ALIASES,
+    ...SHARED_HEALTH_ALIASES,
+    rebuild: "rebuildVectorIndex",
+    rebuild_vector_index: "rebuildVectorIndex",
+    addVector: "addToVectorIndex",
+    add_to_vector_index: "addToVectorIndex",
+    mergeTags: "mergeTags",
+    merge_tags: "mergeTags",
+    registerProject: "registerProject",
+    register_project: "registerProject",
+    updateProject: "updateProject",
+    update_project: "updateProject",
+    deleteProject: "deleteProject",
+    removeProject: "deleteProject",
+    delete_project: "deleteProject"
+  },
+  github: {
+    issues: "getGithubIssues",
+    issue: "getGithubIssue",
+    prs: "getGithubPrs",
+    pr: "getGithubPr",
+    context: "getGithubContext",
+    kanban: "getKanbanBoard",
+    moveKanban: "moveKanbanItem",
+    addKanban: "addKanbanItem",
+    deleteKanban: "deleteKanbanItem",
+    milestones: "getGithubMilestones",
+    milestone: "getGithubMilestone",
+    createMilestone: "createGithubMilestone",
+    updateMilestone: "updateGithubMilestone",
+    deleteMilestone: "deleteGithubMilestone",
+    repoInsights: "getRepoInsights",
+    createIssue: "createGithubIssueWithEntry",
+    closeIssue: "closeGithubIssueWithEntry",
+    copilotReviews: "getCopilotReviews",
+    get_github_issues: "getGithubIssues",
+    get_github_issue: "getGithubIssue",
+    get_github_prs: "getGithubPrs",
+    get_github_pr: "getGithubPr",
+    get_github_context: "getGithubContext",
+    get_kanban_board: "getKanbanBoard",
+    move_kanban_item: "moveKanbanItem",
+    add_kanban_item: "addKanbanItem",
+    delete_kanban_item: "deleteKanbanItem",
+    get_github_milestones: "getGithubMilestones",
+    get_github_milestone: "getGithubMilestone",
+    create_github_milestone: "createGithubMilestone",
+    update_github_milestone: "updateGithubMilestone",
+    delete_github_milestone: "deleteGithubMilestone",
+    get_repo_insights: "getRepoInsights",
+    create_github_issue_with_entry: "createGithubIssueWithEntry",
+    close_github_issue_with_entry: "closeGithubIssueWithEntry",
+    get_copilot_reviews: "getCopilotReviews"
+  },
+  backup: {
+    save: "backupJournal",
+    create: "backupJournal",
+    backup: "backupJournal",
+    list: "listBackups",
+    restore: "restoreBackup",
+    cleanup: "cleanupBackups",
+    backup_journal: "backupJournal",
+    list_backups: "listBackups",
+    restore_backup: "restoreBackup",
+    cleanup_backups: "cleanupBackups"
+  },
+  team: {
+    ...mapToTarget(
+      ["create", "createEntry", "create_entry", "addEntry", "sessionSummary", "teamSessionSummary"],
+      "teamCreateEntry"
+    ),
+    ...mapToTarget(
+      ["recent", "listEntries", "teamListEntries", "list", "entries", "teamList"],
+      "teamGetRecent"
+    ),
+    ...mapToTarget(
+      ["batchCreate", "batchCreateEntries", "bulkCreate", "createEntries", "batchCreateEntry"],
+      "teamBatchCreateEntries"
+    ),
+    ...mapToTarget(["batchUpdate", "batchUpdateEntries", "bulkUpdate", "updateEntries"], "teamBatchUpdateEntries"),
+    ...mapToTarget(["batchDelete", "batchDeleteEntries", "bulkDelete", "deleteEntries"], "teamBatchDeleteEntries"),
+    ...mapToTarget(
+      ["insights", "searchProjects", "listProjects", "getProjects"],
+      "teamGetCrossProjectInsights"
+    ),
+    ...mapToTarget(["updateRole", "changeRole", "setRole"], "teamUpdateMemberRole"),
+    find: "teamSearch",
+    search: "teamSearch",
+    get: "teamGetEntryById",
+    read: "teamGetEntryById",
+    tags: "teamListTags",
+    byDate: "teamSearchByDateRange",
+    update: "teamUpdateEntry",
+    edit: "teamUpdateEntry",
+    delete: "teamDeleteEntry",
+    restore: "teamRestoreEntry",
+    teamRestore: "teamRestoreEntry",
+    mergeTags: "teamMergeTags",
+    stats: "teamGetStatistics",
+    link: "teamLinkEntries",
+    linkEntries: "teamLinkEntries",
+    graph: "teamVisualizeRelationships",
+    visualizeRelationships: "teamVisualizeRelationships",
+    export: "teamExportEntries",
+    exportEntries: "teamExportEntries",
+    exportMarkdown: "teamExportMarkdown",
+    md: "teamExportMarkdown",
+    importMarkdown: "teamImportMarkdown",
+    importMd: "teamImportMarkdown",
+    importNotion: "teamImportExternal",
+    importObsidian: "teamImportExternal",
+    importExternal: "teamImportExternal",
+    trash: "teamListDeletedEntries",
+    deleted: "teamListDeletedEntries",
+    backup: "teamBackup",
+    listBackups: "teamListBackups",
+    semanticSearch: "teamSemanticSearch",
+    vectorStats: "teamGetVectorIndexStats",
+    rebuildIndex: "teamRebuildVectorIndex",
+    addToIndex: "teamAddToVectorIndex",
+    collaborationMatrix: "teamGetCollaborationMatrix",
+    addMember: "teamAddMember",
+    removeMember: "teamRemoveMember",
+    members: "teamListMembers",
+    listMembers: "teamListMembers",
+    getMember: "teamGetMember",
+    addAlias: "teamAddAuthorAlias",
+    removeAlias: "teamRemoveAuthorAlias",
+    aliases: "teamListAuthorAliases",
+    listAliases: "teamListAuthorAliases",
+    resolveAuthor: "teamResolveAuthor",
+    consolidate: "teamConsolidateAuthors",
+    consolidateAuthors: "teamConsolidateAuthors"
+  },
+  git: {
+    history: "getCommitHistory",
+    log: "getCommitHistory",
+    commits: "getCommitHistory",
+    search: "searchCommits",
+    find: "searchCommits",
+    release: "getReleaseInfo",
+    unreleased: "getUnreleasedCommits",
+    analyze: "analyzeCommitPatterns",
+    get_commit_history: "getCommitHistory",
+    search_commits: "searchCommits",
+    get_release_info: "getReleaseInfo",
+    get_unreleased_commits: "getUnreleasedCommits",
+    analyze_commit_patterns: "analyzeCommitPatterns"
+  }
+};
+
+// src/codemode/constants/examples-and-params.ts
+var GROUP_EXAMPLES = {
+  core: [
+    'mj.core.createEntry({ content: "Implemented Code Mode" })',
+    "mj.core.getEntryById({ entry_id: 1 })",
+    "mj.core.getRecentEntries({ limit: 10 })",
+    'mj.core.createEntryMinimal({ content: "Quick note" })',
+    "mj.core.listTags()"
+  ],
+  search: [
+    'mj.search.searchEntries({ query: "performance" })',
+    'mj.search.searchEntries({ query: "performance", mode: "hybrid" })',
+    'mj.search.searchByDateRange({ start_date: "2026-03-01", end_date: "2026-03-11" })',
+    'mj.search.semanticSearch({ query: "authentication patterns" })',
+    "mj.search.semanticSearch({ entry_id: 42 })"
+  ],
+  analytics: [
+    "mj.analytics.getStatistics()",
+    "mj.analytics.getCrossProjectInsights()",
+    "mj.analytics.getProjects()"
+  ],
+  relationships: [
+    'mj.relationships.linkEntries({ from_entry_id: 1, to_entry_id: 2, relationship_type: "implements" })',
+    "mj.relationships.visualizeRelationships({ entry_id: 1 })"
+  ],
+  io: [
+    'mj.io.exportEntries({ format: "json" })',
+    'mj.io.exportMarkdown({ output_dir: "./export" })',
+    'mj.io.importMarkdown({ source_dir: "./import" })',
+    'mj.io.importExternal({ source_dir: "./import", source_format: "notion" })'
+  ],
+  admin: [
+    'mj.admin.updateEntry({ entry_id: 1, content: "Updated content" })',
+    "mj.admin.deleteEntry({ entry_id: 1 })",
+    "mj.admin.restoreEntry({ entry_id: 1 })",
+    'mj.admin.mergeTags({ source_tag: "old", target_tag: "new" })',
+    'mj.admin.batchCreateEntries({ entries: [{ content: "First" }, { content: "Second" }] })',
+    "mj.admin.rebuildVectorIndex()",
+    "mj.admin.addToVectorIndex({ entry_id: 1 })"
+  ],
+  github: [
+    '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()"
+  ],
+  backup: [
+    "mj.backup.backupJournal()",
+    "mj.backup.listBackups()",
+    'mj.backup.restoreBackup({ filename: "backup-2026-03-11.db" })'
+  ],
+  team: [
+    'mj.team.teamCreateEntry({ content: "Team update" })',
+    "mj.team.teamGetRecent({ limit: 5 })",
+    'mj.team.teamSearch({ query: "release" })',
+    "mj.team.teamGetEntryById({ entry_id: 1 })",
+    "mj.team.teamListTags()",
+    'mj.team.teamUpdateEntry({ entry_id: 1, content: "Updated" })',
+    "mj.team.teamRestoreEntry({ entry_id: 1 })",
+    'mj.team.teamBatchCreateEntries({ entries: [{ content: "Team A" }] })',
+    "mj.team.teamGetStatistics()",
+    'mj.team.teamExportEntries({ format: "json" })',
+    "mj.team.teamBackup()",
+    'mj.team.teamSemanticSearch({ query: "deployment" })',
+    "mj.team.teamGetCrossProjectInsights()"
+  ],
+  git: [
+    "mj.git.getCommitHistory({ maxCount: 10 })",
+    'mj.git.searchCommits({ query: "fix" })',
+    "mj.git.getReleaseInfo()",
+    "mj.git.getUnreleasedCommits()",
+    "mj.git.analyzeCommitPatterns({ maxCount: 20 })"
+  ]
+};
+var POSITIONAL_PARAM_MAP = {
+  // Core
+  createEntry: "content",
+  getEntryById: "entry_id",
+  getRecentEntries: "limit",
+  createEntryMinimal: "content",
+  testSimple: "message",
+  writeQuery: "content",
+  getEntryHistory: "entry_id",
+  // Search
+  searchEntries: "query",
+  searchByDateRange: ["start_date", "end_date"],
+  semanticSearch: "query",
+  crossTeamSearch: "query",
+  listDeletedEntries: "limit",
+  // Relationships
+  linkEntries: ["from_entry_id", "to_entry_id", "relationship_type"],
+  link_entries: ["from_entry_id", "to_entry_id", "relationship_type"],
+  visualizeRelationships: "entry_id",
+  visualize_relationships: "entry_id",
+  // Export
+  exportEntries: "format",
+  exportMarkdown: "output_dir",
+  importMarkdown: "source_dir",
+  importExternal: "source_dir",
+  // Admin
+  updateEntry: "entry_id",
+  deleteEntry: "entry_id",
+  restoreEntry: "entry_id",
+  addToVectorIndex: "entry_id",
+  mergeTags: ["source_tag", "target_tag"],
+  batchCreateEntries: "entries",
+  batchUpdateEntries: "updates",
+  batchDeleteEntries: "entry_ids",
+  searchAuditLog: "tool_name",
+  updateConfiguration: "tool_filter",
+  registerProject: ["name", "absolute_path", "project_number"],
+  updateProject: ["name", "new_name", "absolute_path", "project_number"],
+  deleteProject: "name",
+  getProject: "name",
+  getProjectByName: "name",
+  get_project_by_name: "name",
+  getProjectByNumber: "name",
+  get_project_by_number: "name",
+  findProject: "name",
+  find_project: "name",
+  // GitHub
+  getGithubIssue: "issue_number",
+  getGithubPr: "pr_number",
+  getKanbanBoard: "project_number",
+  moveKanbanItem: ["item_id", "target_status"],
+  addKanbanItem: "issue_number",
+  deleteKanbanItem: "item_id",
+  getGithubMilestone: "milestone_number",
+  createGithubMilestone: "title",
+  updateGithubMilestone: "milestone_number",
+  deleteGithubMilestone: "milestone_number",
+  createGithubIssueWithEntry: "title",
+  closeGithubIssueWithEntry: "issue_number",
+  getCopilotReviews: "pr_number",
+  // Backup
+  backupJournal: "name",
+  restoreBackup: ["filename", "confirm"],
+  cleanupBackups: "keep_count",
+  // Team
+  teamCreateEntry: "content",
+  teamGetRecent: "limit",
+  teamSearch: "query",
+  teamGetEntryById: "entry_id",
+  teamSearchByDateRange: ["start_date", "end_date"],
+  teamUpdateEntry: "entry_id",
+  teamDeleteEntry: "entry_id",
+  teamRestoreEntry: "entry_id",
+  teamMergeTags: ["source_tag", "target_tag"],
+  teamBatchCreateEntries: "entries",
+  teamBatchUpdateEntries: "updates",
+  teamBatchDeleteEntries: "entry_ids",
+  teamLinkEntries: ["from_entry_id", "to_entry_id", "relationship_type"],
+  teamVisualizeRelationships: "entry_id",
+  teamExportEntries: "format",
+  teamExportMarkdown: "output_dir",
+  teamImportMarkdown: "source_dir",
+  teamImportExternal: "source_dir",
+  teamSemanticSearch: "query",
+  teamAddToVectorIndex: "entry_id",
+  teamAddAuthorAlias: ["alias", "canonical_author"],
+  teamRemoveAuthorAlias: "alias",
+  teamListAuthorAliases: "canonical_author",
+  teamResolveAuthor: "author",
+  teamConsolidateAuthors: "canonical_author",
+  // Team Members
+  teamAddMember: ["author", "role"],
+  teamRemoveMember: "author",
+  teamUpdateMemberRole: ["author", "role"],
+  teamGetMember: "author",
+  // Git
+  getCommitHistory: "maxCount",
+  searchCommits: "query",
+  getReleaseInfo: "ref",
+  analyzeCommitPatterns: "maxCount"
+};
+var GROUP_PREFIX_MAP = {
+  core: "",
+  search: "",
+  analytics: "",
+  relationships: "",
+  io: "",
+  admin: "",
+  github: "",
+  backup: "",
+  team: "",
+  git: "",
+  codemode: "mj_"
+};
+var KEEP_PREFIX_GROUPS = /* @__PURE__ */ new Set(["github", "team"]);
+
+// src/codemode/api/git-api.ts
+function applyGitInterceptions(methodName, args) {
+  const gitMethods = [
+    "get_commit_history",
+    "getCommitHistory",
+    "search_commits",
+    "searchCommits",
+    "get_release_info",
+    "getReleaseInfo",
+    "get_unreleased_commits",
+    "getUnreleasedCommits",
+    "analyze_commit_patterns",
+    "analyzeCommitPatterns"
+  ];
+  if (gitMethods.includes(methodName) && args.length === 1 && typeof args[0] === "object" && args[0] !== null) {
+    const obj = args[0];
+    for (const key of ["text", "message", "description", "q", "search"]) {
+      if (obj[key] !== void 0 && obj["query"] === void 0 && (methodName.includes("search_commits") || methodName.includes("searchCommits"))) {
+        obj["query"] = obj[key];
+        Reflect.deleteProperty(obj, key);
+      }
+    }
+    if (obj["keep"] !== void 0 && obj["maxCount"] === void 0 && obj["max_count"] === void 0) {
+      obj["maxCount"] = obj["keep"];
+      delete obj["keep"];
+    }
+    if (obj["limit"] !== void 0 && obj["maxCount"] === void 0 && obj["max_count"] === void 0) {
+      obj["maxCount"] = obj["limit"];
+      delete obj["limit"];
+    }
+    if (!methodName.includes("search") && (obj["q"] !== void 0 || obj["query"] !== void 0 || obj["search"] !== void 0)) {
+      return { error: {
+        success: false,
+        error: `${methodName} does not support search queries (q/query/search). It only retrieves history or analysis.`,
+        code: "VALIDATION_ERROR",
+        category: "validation",
+        suggestion: "Remove the query parameter, or use search_commits for text search.",
+        recoverable: true
+      } };
+    }
+    return { args: [obj] };
+  }
+  return null;
+}
+
+// src/codemode/normalizers/shared-utils.ts
+function isRecord(val) {
+  return typeof val === "object" && val !== null && !Array.isArray(val);
+}
+function safeString(val) {
+  if (typeof val === "string") return val;
+  if (typeof val === "number" || typeof val === "boolean") return String(val);
+  if (typeof val === "object" && val !== null) {
+    try {
+      return JSON.stringify(val, null, 2);
+    } catch {
+      return "";
+    }
+  }
+  return "";
+}
+var PARAM_ALIASES = {
+  text: "content",
+  body: "content",
+  note: "content",
+  title: "content",
+  entry: "entry_id",
+  q: "query",
+  issue: "issue_number",
+  pr: "pr_number",
+  pr_id: "pr_number",
+  project: "project_number",
+  project_id: "project_number",
+  project_name: "project_number",
+  projectName: "project_number",
+  proj: "project_number",
+  milestone_id: "milestone_number",
+  issue_id: "issue_number",
+  pull_request_id: "pr_number",
+  pull_number: "pr_number",
+  user: "target_user",
+  assignee: "target_user",
+  repo_name: "repo",
+  version: "expected_version",
+  search: "query",
+  term: "query",
+  keyword: "query",
+  source: "source_tag",
+  target: "target_tag",
+  from: "from_entry_id",
+  to: "to_entry_id",
+  kind: "entry_type",
+  format_type: "format",
+  webhook: "report_webhook_url",
+  comment: "resolution",
+  resolution_comment: "resolution",
+  severity: "flag_type",
+  sort: "sort_by",
+  order_by: "sort_by",
+  order: "sort_by",
+  keep: "keep_count",
+  path: "source_dir",
+  impactScore: "impact_score",
+  trustScore: "trust_score",
+  validationStatus: "validation_status",
+  team_id: "workspace_id",
+  team: "workspace_id"
+};
+var ENTRY_TYPE_ALIASES = {
+  "session-summary": "retrospective",
+  "session_summary": "retrospective",
+  "team-session-summary": "retrospective",
+  "team_session_summary": "retrospective",
+  "team session summary": "retrospective",
+  "summary": "retrospective",
+  "bug": "bug_fix",
+  "feature": "feature_implementation",
+  "note": "technical_note",
+  "technical-note": "technical_note",
+  "reflection": "personal_reflection",
+  "decision": "project_decision",
+  "review": "code_review",
+  "code": "technical_note",
+  "coding": "technical_note",
+  "progress": "development_note",
+  "status": "development_note",
+  "update": "development_note",
+  "test": "system_integration_test",
+  "testing": "system_integration_test",
+  "task": "technical_note"
+};
+var TAG_ALIASES = {
+  "session_summary": "session-summary",
+  "team_session_summary": "session-summary",
+  "team-session-summary": "session-summary",
+  "team session summary": "session-summary",
+  "commit_narrative": "commit-narrative",
+  "bug_fix": "bug-fix",
+  "feature_implementation": "feature"
+};
+function deduplicateSectionHeader(str, headerRegexStr) {
+  let count = 0;
+  return str.replace(new RegExp(headerRegexStr, "gim"), (match) => {
+    count++;
+    return count === 1 ? match : "";
+  });
+}
+function healSessionSummaryContent(content, options) {
+  let healed = content;
+  if (options?.normalizeSynonyms !== false) {
+    healed = healed.replace(/^#+\s+(?:Accomplishments|Completed|Done|What I did|What we did)\s*$/gim, "## Accomplished");
+    healed = healed.replace(/^#+\s+(?:Blockers|Unfinished|Unfinished\/?Blocked|Blocked)\s*$/gim, "## Unfinished / Blocked");
+    healed = healed.replace(/^#+\s+(?:Next Session|Context|Next steps)\s*$/gim, "## Context for Next Session");
+  }
+  healed = healed.replace(/(?:^#+\s+Accomplished\s*\n-\s*(?:None\.?|)\s*){2,}/gim, "## Accomplished\n- None.\n");
+  healed = healed.replace(/(?:^#+\s+Unfinished \/ Blocked\s*\n-\s*(?:None\.?|)\s*){2,}/gim, "## Unfinished / Blocked\n- None.\n");
+  healed = healed.replace(/(?:^#+\s+Context for Next Session\s*\n-\s*(?:None\.?|)\s*){2,}/gim, "## Context for Next Session\n- None.\n");
+  healed = healed.replace(/(?:^#+\s+Commits\s*\n-\s*(?:None\.?|)\s*){2,}/gim, "## Commits\n- None.\n");
+  healed = deduplicateSectionHeader(healed, "^#+\\s+Accomplished");
+  healed = deduplicateSectionHeader(healed, "^#+\\s+Unfinished \\/ Blocked");
+  healed = deduplicateSectionHeader(healed, "^#+\\s+Context for Next Session");
+  healed = deduplicateSectionHeader(healed, "^#+\\s+Commits");
+  if (options?.usePeriodOnNone === true) {
+    const requiredHeaders = [
+      "## Accomplished",
+      "## Unfinished / Blocked",
+      "## Context for Next Session",
+      "## Commits"
+    ];
+    for (const header of requiredHeaders) {
+      const cleanHeader = header.replace(/^#+\s+/, "").replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/ /g, "\\s*");
+      const regex = new RegExp(`#+\\s+${cleanHeader}`, "i");
+      if (!regex.test(healed)) {
+        healed += `
+
+${header}
+- None.`;
+      }
+    }
+  } else {
+    if (!/#+\s+Accomplished/i.test(healed)) healed += "\n\n## Accomplished\n- \n";
+    if (!/#+\s+Unfinished \/ Blocked/i.test(healed)) healed += "\n\n## Unfinished / Blocked\n- None\n";
+    if (!/#+\s+Context for Next Session/i.test(healed)) healed += "\n\n## Context for Next Session\n- \n";
+    if (!/#+\s+Commits/i.test(healed)) healed += "\n\n## Commits\n- None\n";
+  }
+  return healed.trim();
+}
+function healAutoContext(result) {
+  if (!("auto_context" in result)) return;
+  const ac = result["auto_context"];
+  if (typeof ac === "string") {
+    try {
+      const parsed = JSON.parse(ac.replace(/'/g, '"'));
+      if (!isRecord(parsed)) return;
+      let changed = false;
+      for (const alias of ["commit_shas", "shas", "commit_sha", "commitShas"]) {
+        if (alias in parsed) {
+          parsed["commits"] = parsed[alias];
+          Reflect.deleteProperty(parsed, alias);
+          changed = true;
+        }
+      }
+      if ("commits" in parsed && typeof parsed["commits"] === "string") {
+        parsed["commits"] = [parsed["commits"]];
+        changed = true;
+      }
+      if (changed) {
+        result["auto_context"] = JSON.stringify(parsed);
+      }
+    } catch {
+    }
+  } else if (isRecord(ac)) {
+    for (const alias of ["commit_shas", "shas", "commit_sha", "commitShas"]) {
+      if (alias in ac) {
+        ac["commits"] = ac[alias];
+        Reflect.deleteProperty(ac, alias);
+      }
+    }
+    if ("commits" in ac && typeof ac["commits"] === "string") {
+      ac["commits"] = [ac["commits"]];
+    }
+  }
+}
+
+// src/codemode/normalizers/generic-interceptions.ts
+var NUMERIC_ID_KEYS = [
+  "entry_id",
+  "entryId",
+  "id",
+  "from_entry_id",
+  "fromEntryId",
+  "to_entry_id",
+  "toEntryId",
+  "project_number",
+  "projectNumber",
+  "issue_number",
+  "issueNumber",
+  "pr_number",
+  "prNumber",
+  "milestone_number",
+  "milestoneNumber",
+  "offset",
+  "limit"
+];
+var EXECUTE_METHODS = /* @__PURE__ */ new Set([
+  "execute",
+  "execute_code",
+  "executeCode",
+  "mj_execute_code",
+  "mjExecuteCode",
+  "mysql_execute_code",
+  "mysqlExecuteCode"
+]);
+var CREATE_ENTRY_METHODS = /* @__PURE__ */ new Set([
+  "create_entry",
+  "createEntry",
+  "team_create_entry",
+  "teamCreateEntry"
+]);
+function applyGenericInterceptions(methodName, args) {
+  if (EXECUTE_METHODS.has(methodName) && args.length === 1 && typeof args[0] === "string") {
+    args = [{ code: args[0] }];
+  }
+  if (CREATE_ENTRY_METHODS.has(methodName) && args.length === 1 && typeof args[0] === "string") {
+    args = [{ content: args[0] }];
+  }
+  if (args.length === 2 && typeof args[0] === "string" && isRecord(args[1])) {
+    const firstStr = args[0].trim();
+    const mergedObj = { ...args[1] };
+    if (mergedObj["workspace_id"] === void 0 && mergedObj["workspaceId"] === void 0) {
+      mergedObj["workspace_id"] = firstStr;
+    } else if (mergedObj["title"] === void 0 && mergedObj["content"] === void 0) {
+      mergedObj["title"] = firstStr;
+    }
+    args = [mergedObj];
+  }
+  if (args.length !== 1 || !isRecord(args[0])) return { args };
+  const obj = { ...args[0] };
+  args[0] = obj;
+  cleanSdkMetadataKeys(obj);
+  normalizeSearchGrepAliases(methodName, obj);
+  extractMetadataContextAliases(obj);
+  coerceNumericStringIds(obj);
+  normalizeGenericFieldAliases(obj);
+  if (CREATE_ENTRY_METHODS.has(methodName)) {
+    resolveCreateEntryProjectContext(obj);
+  }
+  if (typeof obj["sort_by"] === "string") {
+    const lowerSort = obj["sort_by"].toLowerCase();
+    if (lowerSort.endsWith("_asc")) {
+      obj["sort_by"] = obj["sort_by"].replace(/_asc$/i, "");
+      obj["sort_order"] ??= "asc";
+    } else if (lowerSort.endsWith("_desc")) {
+      obj["sort_by"] = obj["sort_by"].replace(/_desc$/i, "");
+      obj["sort_order"] ??= "desc";
+    }
+  }
+  if (EXECUTE_METHODS.has(methodName)) {
+    normalizeExecuteCodeAliases(obj);
+  } else if (obj["repo"] !== void 0 && obj["repo_name"] === void 0) {
+    obj["repo_name"] = obj["repo"];
+    delete obj["repo"];
+  }
+  for (const [src, dst] of [["item_type", "type"], ["category", "type"], ["metadata", "context"]]) {
+    if (obj[src] !== void 0 && obj[dst] === void 0) {
+      obj[dst] = obj[src];
+      Reflect.deleteProperty(obj, src);
+    }
+  }
+  if (CREATE_ENTRY_METHODS.has(methodName) || methodName === "update_entry" || methodName === "updateEntry") {
+    synthesizeEntryMutationFields(obj);
+  }
+  if (obj["search"] !== void 0 && obj["query"] === void 0) {
+    obj["query"] = obj["search"];
+    delete obj["search"];
+  }
+  if (["import_external", "importExternal", "team_import_external", "teamImportExternal"].includes(methodName) && obj["source_dir"] === void 0 && obj["filename"] !== void 0) {
+    obj["source_dir"] = obj["filename"];
+    delete obj["filename"];
+  }
+  return { args };
+}
+function cleanSdkMetadataKeys(obj) {
+  for (const k of ["_u_r_i", "_uri"]) {
+    if (obj[k] !== void 0) {
+      if (obj["uri"] === void 0 && obj["Uri"] === void 0) obj["uri"] = obj[k];
+      Reflect.deleteProperty(obj, k);
+    }
+  }
+  if (obj["_url"] !== void 0) {
+    if (obj["url"] === void 0 && obj["Url"] === void 0) obj["url"] = obj["_url"];
+    delete obj["_url"];
+  }
+  delete obj["_server_name"];
+  delete obj["_tool_name"];
+  delete obj["_meta"];
+  for (const key of Object.keys(obj)) {
+    if (key.startsWith("_") && key !== "_journal") {
+      const strippedKey = key.replace(/^_+/, "");
+      if (strippedKey.length > 0 && obj[strippedKey] === void 0) obj[strippedKey] = obj[key];
+      Reflect.deleteProperty(obj, key);
+    }
+  }
+}
+function normalizeSearchGrepAliases(methodName, obj) {
+  const lower = methodName.toLowerCase();
+  if (!lower.includes("search") && !lower.includes("grep") && !lower.includes("find")) return;
+  if (obj["search_path"] === void 0) {
+    const p = obj["searchPath"] ?? obj["SearchPath"] ?? obj["path"] ?? obj["Path"] ?? obj["dir"] ?? obj["directory"] ?? obj["cwd"];
+    if (typeof p === "string") obj["search_path"] = p;
+  }
+  if (obj["query"] === void 0) {
+    const q = obj["Query"] ?? obj["pattern"] ?? obj["text"] ?? obj["search"] ?? obj["q"];
+    if (typeof q === "string") obj["query"] = q;
+  }
+  if (obj["file_pattern"] === void 0) {
+    const fp = obj["filePattern"] ?? obj["FilePattern"] ?? obj["include"];
+    if (typeof fp === "string") obj["file_pattern"] = fp;
+  }
+  if (obj["case_insensitive"] === void 0) {
+    const ci = obj["caseInsensitive"] ?? obj["CaseInsensitive"] ?? obj["ignore_case"] ?? obj["ignoreCase"];
+    if (typeof ci === "boolean") obj["case_insensitive"] = ci;
+  }
+  if (obj["is_regex"] === void 0) {
+    const ir = obj["isRegex"] ?? obj["IsRegex"] ?? obj["regex"];
+    if (typeof ir === "boolean") obj["is_regex"] = ir;
+  }
+  if (obj["match_per_line"] === void 0) {
+    const mpl = obj["matchPerLine"] ?? obj["MatchPerLine"];
+    if (typeof mpl === "boolean") obj["match_per_line"] = mpl;
+  }
+}
+function extractMetadataContextAliases(obj) {
+  const metaObj = isRecord(obj["metadata"]) ? obj["metadata"] : isRecord(obj["context"]) ? obj["context"] : void 0;
+  if (!metaObj) return;
+  obj["project_number"] ??= metaObj["project_number"] ?? metaObj["projectNumber"];
+  obj["session_id"] ??= metaObj["session_id"] ?? metaObj["sessionId"];
+  obj["type"] ??= metaObj["type"] ?? metaObj["entry_type"] ?? metaObj["category"];
+  obj["tags"] ??= metaObj["tags"];
+  obj["workspace_id"] ??= metaObj["workspace_id"] ?? metaObj["workspaceId"];
+}
+function coerceNumericStringIds(obj) {
+  for (const key of NUMERIC_ID_KEYS) {
+    const val = obj[key];
+    if (typeof val === "string") {
+      const strVal = val.trim();
+      if (/^-?\d+$/.test(strVal)) {
+        const parsed = parseInt(strVal, 10);
+        if (!isNaN(parsed)) obj[key] = parsed;
+      } else if ((key === "project_number" || key === "projectNumber") && /^p-?\d+$/i.test(strVal)) {
+        const parsed = parseInt(strVal.replace(/^p-?/i, ""), 10);
+        if (!isNaN(parsed)) obj[key] = parsed;
+      } else if (key === "project_number" || key === "projectNumber") {
+        Reflect.deleteProperty(obj, key);
+      }
+    }
+  }
+}
+function normalizeGenericFieldAliases(obj) {
+  for (const [src, dst] of [
+    ["user", "target_user"],
+    ["severity", "flag_type"],
+    ["msg", "message"],
+    ["sort", "sort_by"],
+    ["sortBy", "sort_by"],
+    ["orderBy", "sort_by"],
+    ["order_by", "sort_by"],
+    ["validation", "validation_status"],
+    ["validationStatus", "validation_status"]
+  ]) {
+    if (obj[src] !== void 0) {
+      if (obj[dst] === void 0) obj[dst] = obj[src];
+      Reflect.deleteProperty(obj, src);
+    }
+  }
+  for (const [aliasKey, targetKey] of [
+    ["confidence", "trust_score"],
+    ["trust", "trust_score"],
+    ["trustScore", "trust_score"],
+    ["impact", "impact_score"],
+    ["impactScore", "impact_score"]
+  ]) {
+    if (obj[aliasKey] !== void 0) {
+      if (obj[targetKey] === void 0) {
+        obj[targetKey] = typeof obj[aliasKey] === "string" ? Number(obj[aliasKey]) : obj[aliasKey];
+      }
+      Reflect.deleteProperty(obj, aliasKey);
+    }
+  }
+  if (obj["validation_status"] !== void 0 && obj["validation_status"] !== null) {
+    const vs = typeof obj["validation_status"] === "string" ? obj["validation_status"].trim().toLowerCase() : obj["validation_status"];
+    if (vs === true || typeof vs === "string" && ["pass", "success", "ok", "passed", "validated", "valid", "verified", "true", "1"].includes(vs)) {
+      obj["validation_status"] = "passed";
+    } else if (vs === false || typeof vs === "string" && ["fail", "failed", "error", "failing", "false", "0"].includes(vs)) {
+      obj["validation_status"] = "failed";
+    } else if (typeof vs === "string" && !["passed", "none", "failed"].includes(vs)) {
+      obj["validation_status"] = "none";
+    }
+  }
+  for (const projAlias of ["project_name", "projectName"]) {
+    if (obj[projAlias] !== void 0) {
+      if (obj["project_number"] === void 0) {
+        const num = Number(obj[projAlias]);
+        const strVal = typeof obj[projAlias] === "string" || typeof obj[projAlias] === "number" ? String(obj[projAlias]) : "";
+        if (!Number.isNaN(num) && strVal.trim() !== "") obj["project_number"] = num;
+      }
+      Reflect.deleteProperty(obj, projAlias);
+    }
+  }
+  if (obj["project"] !== void 0) {
+    if (obj["project_number"] === void 0) {
+      const num = Number(obj["project"]);
+      const strVal = typeof obj["project"] === "string" || typeof obj["project"] === "number" ? String(obj["project"]) : "";
+      if (!Number.isNaN(num) && strVal.trim() !== "") {
+        obj["project_number"] = num;
+      } else if (typeof obj["project"] === "string" && obj["project"].trim() !== "") {
+        const existingTags = Array.isArray(obj["tags"]) ? obj["tags"].filter((t) => typeof t === "string") : [];
+        obj["tags"] = [...existingTags, obj["project"].trim()];
+      }
+    }
+    delete obj["project"];
+  }
+}
+function resolveCreateEntryProjectContext(obj) {
+  let projNum = typeof obj["project_number"] === "number" ? obj["project_number"] : void 0;
+  if (typeof obj["project_number"] === "string") {
+    const cleaned = obj["project_number"].trim();
+    let parsedNum = Number(cleaned);
+    if (Number.isNaN(parsedNum) && /^p-?\d+$/i.test(cleaned)) {
+      parsedNum = Number(cleaned.replace(/^p-?/i, ""));
+    }
+    if (!Number.isNaN(parsedNum) && cleaned !== "") {
+      projNum = parsedNum;
+      obj["project_number"] = parsedNum;
+    } else {
+      if (obj["workspace_id"] === void 0 || obj["workspace_id"] === null || obj["workspace_id"] === "" || obj["workspace_id"] === "default") {
+        obj["workspace_id"] = cleaned;
+      }
+      delete obj["project_number"];
+    }
+  }
+  const content = typeof obj["content"] === "string" ? obj["content"] : void 0;
+  const tags = Array.isArray(obj["tags"]) ? obj["tags"].filter((t) => typeof t === "string") : void 0;
+  const resolved = resolveProjectContext({
+    ...typeof obj["workspace_id"] === "string" ? { workspace_id: obj["workspace_id"] } : {},
+    ...projNum !== void 0 ? { project_number: projNum } : {},
+    ...content !== void 0 ? { content } : {},
+    ...tags !== void 0 ? { tags } : {}
+  });
+  if (resolved.workspaceId !== void 0 && resolved.workspaceId !== "" && (obj["workspace_id"] === void 0 || obj["workspace_id"] === null || obj["workspace_id"] === "" || obj["workspace_id"] === "default")) {
+    if (resolved.workspaceId !== "default") {
+      obj["workspace_id"] = resolved.workspaceId;
+    } else if (process.env["MCP_WORKSPACE_ID"] !== void 0 && process.env["MCP_WORKSPACE_ID"] !== "") {
+      obj["workspace_id"] = process.env["MCP_WORKSPACE_ID"];
+    } else {
+      obj["workspace_id"] = "default";
+    }
+  }
+  if (obj["project_number"] === void 0 && resolved.projectNumber !== void 0) {
+    obj["project_number"] = resolved.projectNumber;
+  }
+}
+function normalizeExecuteCodeAliases(obj) {
+  if (obj["repo_name"] !== void 0 && obj["repo"] === void 0) {
+    obj["repo"] = obj["repo_name"];
+    delete obj["repo_name"];
+  }
+  if (obj["code"] !== void 0) return;
+  const codeAlias = obj["script"] ?? obj["js"] ?? obj["javascript"] ?? obj["query"] ?? obj["command"] ?? obj["content"] ?? obj["eval"] ?? obj["source"] ?? obj["body"] ?? obj["expression"] ?? obj["fn"] ?? obj["exec"] ?? obj["code_snippet"] ?? obj["raw_code"] ?? obj["statement"] ?? obj["statements"] ?? obj["codeBlock"] ?? obj["code_block"] ?? obj["script_content"] ?? obj["js_code"] ?? obj["code_string"] ?? obj["action"] ?? obj["task"] ?? obj["instruction"] ?? obj["instructions"] ?? obj["input"] ?? obj["payload"] ?? obj["text"];
+  if (typeof codeAlias === "string") obj["code"] = codeAlias;
+  else if (isRecord(obj["payload"])) obj["code"] = JSON.stringify(obj["payload"]);
+  else if (isRecord(obj["entry"])) obj["code"] = JSON.stringify(obj["entry"]);
+  else if (isRecord(obj["input"])) obj["code"] = JSON.stringify(obj["input"]);
+  else if (obj["action"] !== void 0 || obj["task"] !== void 0 || obj["notes"] !== void 0 || obj["changes"] !== void 0) {
+    obj["code"] = JSON.stringify(obj);
+  } else {
+    for (const [k, v] of Object.entries(obj)) {
+      if (typeof v === "string" && v.trim().length > 0 && !["repo", "workspace_id", "expected_version", "auto_version", "project_number"].includes(k)) {
+        obj["code"] = v;
+        break;
+      }
+    }
+  }
+}
+function synthesizeEntryMutationFields(obj) {
+  if (obj["type"] !== void 0 && obj["entry_type"] === void 0) {
+    obj["entry_type"] = obj["type"];
+    delete obj["type"];
+  }
+  if (typeof obj["entry_type"] === "string") {
+    const etLower = obj["entry_type"].toLowerCase().trim();
+    if (["bug", "bugfix", "bug_fix", "bug-fix", "hotfix", "defect"].includes(etLower)) obj["entry_type"] = "bug_fix";
+    else if (["progress", "status", "development"].includes(etLower)) obj["entry_type"] = "development_note";
+    else if (etLower === "feature") obj["entry_type"] = "feature_implementation";
+    else if (etLower === "meeting") obj["entry_type"] = "meeting_notes";
+    else if (["task", "chore", "refactor", "fix", "update", "technical", "note", "documentation", "code", "coding"].includes(etLower)) {
+      obj["entry_type"] = "technical_note";
+    } else if (["session-summary", "session_summary", "team-session-summary", "team_session_summary", "team session summary"].includes(etLower)) {
+      obj["entry_type"] = "retrospective";
+    }
+  }
+  const contentParts = [];
+  const consumeGroup = (keys, format) => {
+    let found;
+    for (const k of keys) {
+      if (found === void 0 && obj[k] !== void 0) found = obj[k];
+      Reflect.deleteProperty(obj, k);
+    }
+    if (found !== void 0) {
+      const s = format(found);
+      if (s !== "") contentParts.push(s);
+    }
+  };
+  consumeGroup(["title", "heading", "subject", "name"], (v) => {
+    const s = safeString(v);
+    return s !== "" ? `# ${s}` : "";
+  });
+  consumeGroup(["description", "details", "summary", "notes", "text", "message"], safeString);
+  consumeGroup(["context"], (v) => {
+    const s = safeString(v);
+    return s !== "" ? `**Context:** ${s}` : "";
+  });
+  consumeGroup(["focus", "goal", "objective"], (v) => {
+    const s = safeString(v);
+    return s !== "" ? `**Focus:** ${s}` : "";
+  });
+  consumeGroup(["resolution", "fix", "solution", "result"], (v) => {
+    const s = safeString(v);
+    return s !== "" ? `**Resolution:** ${s}` : "";
+  });
+  consumeGroup(["artifacts", "files", "changes", "modified_files"], (v) => {
+    const s = Array.isArray(v) ? v.map(safeString).join(", ") : safeString(v);
+    return s !== "" ? `**Artifacts:** ${s}` : "";
+  });
+  consumeGroup(["findings", "results", "key_findings", "discoveries"], (v) => {
+    const s = Array.isArray(v) ? v.map((f) => `- ${safeString(f)}`).join("\n") : safeString(v);
+    return s !== "" ? `**Findings:**
+${s}` : "";
+  });
+  if (obj["content"] !== void 0) {
+    const existing = safeString(obj["content"]);
+    if (contentParts.length > 0) {
+      obj["content"] = existing !== "" ? `${existing}
+
+${contentParts.join("\n\n")}` : contentParts.join("\n\n");
+    }
+  } else if (contentParts.length > 0) {
+    obj["content"] = contentParts.join("\n\n");
+  }
+  if (typeof obj["content"] === "string") {
+    obj["content"] = obj["content"].replace(/\\+'/g, "'").replace(/\\+"/g, '"');
+  }
+}
+
+// src/codemode/normalizers/entry-and-search-interceptions.ts
+var SEARCH_METHODS = /* @__PURE__ */ new Set([
+  "search_entries",
+  "searchEntries",
+  "team_search",
+  "teamSearch",
+  "search_by_date_range",
+  "searchByDateRange",
+  "team_search_by_date_range",
+  "teamSearchByDateRange",
+  "semantic_search",
+  "semanticSearch",
+  "team_semantic_search",
+  "teamSemanticSearch",
+  "cross_team_search",
+  "crossTeamSearch"
+]);
+var EXACT_MATCH_SEARCH_METHODS = /* @__PURE__ */ new Set([
+  "search_entries",
+  "searchEntries",
+  "team_search",
+  "teamSearch",
+  "search_by_date_range",
+  "searchByDateRange",
+  "team_search_by_date_range",
+  "teamSearchByDateRange",
+  "cross_team_search",
+  "crossTeamSearch"
+]);
+var SINGLE_ID_METHODS = /* @__PURE__ */ new Set([
+  "delete_entry",
+  "deleteEntry",
+  "restore_entry",
+  "restoreEntry",
+  "get_entry_by_id",
+  "getEntryById",
+  "team_get_entry_by_id",
+  "teamGetEntryById",
+  "get_entry_history",
+  "getEntryHistory",
+  "add_to_vector_index",
+  "addToVectorIndex",
+  "team_add_to_vector_index",
+  "teamAddToVectorIndex",
+  "add_to_index",
+  "addToIndex",
+  "update_entry",
+  "updateEntry",
+  "team_update_entry",
+  "teamUpdateEntry",
+  "edit",
+  "update",
+  "team_delete_entry",
+  "teamDeleteEntry",
+  "delete",
+  "team_restore_entry",
+  "teamRestoreEntry",
+  "restore",
+  "team_restore",
+  "teamRestore"
+]);
+var CREATE_METHODS = /* @__PURE__ */ new Set([
+  "create_entry",
+  "createEntry",
+  "team_create_entry",
+  "teamCreateEntry",
+  "add_entry",
+  "addEntry",
+  "mj_add_entry",
+  "mjAddEntry",
+  "create_journal_entry",
+  "createJournalEntry",
+  "insert_entry",
+  "insertEntry"
+]);
+var SESSION_SUMMARY_METHODS = /* @__PURE__ */ new Set([
+  "create_entry",
+  "createEntry",
+  "team_create_entry",
+  "teamCreateEntry",
+  "update_entry",
+  "updateEntry",
+  "team_update_entry",
+  "teamUpdateEntry"
+]);
+function validationError(error, suggestion) {
+  return {
+    error: {
+      success: false,
+      error,
+      code: "VALIDATION_ERROR",
+      category: "validation",
+      suggestion,
+      recoverable: true
+    }
+  };
+}
+function applyEntryAndSearchInterceptions(methodName, args) {
+  if (SEARCH_METHODS.has(methodName) && args.length === 1 && isRecord(args[0])) {
+    const obj = { ...args[0] };
+    args[0] = obj;
+    const isDateRange = ["search_by_date_range", "searchByDateRange", "team_search_by_date_range", "teamSearchByDateRange"].includes(methodName);
+    if (isDateRange && ["q", "query", "text", "message", "description", "keep", "path"].some((k) => obj[k] !== void 0)) {
+      return validationError(
+        `${methodName} does not support search queries. It only searches by date.`,
+        "Use team_search (or search_entries) if you want to search by text, or remove the text/query parameters."
+      );
+    }
+    for (const alias of ["q", "text", "message", "description", "path", "keep"]) {
+      if (obj[alias] !== void 0 && obj["query"] === void 0) {
+        obj["query"] = obj[alias];
+        Reflect.deleteProperty(obj, alias);
+      }
+    }
+    if (obj["start"] !== void 0 && obj["start_date"] === void 0) {
+      obj["start_date"] = obj["start"];
+      delete obj["start"];
+    }
+    if (obj["end"] !== void 0 && obj["end_date"] === void 0) {
+      obj["end_date"] = obj["end"];
+      delete obj["end"];
+    }
+    if (typeof obj["limit"] === "string") {
+      const parsed = parseInt(obj["limit"], 10);
+      if (!isNaN(parsed)) obj["limit"] = parsed;
+    }
+    if (!["search_entries", "searchEntries", "team_search", "teamSearch"].includes(methodName) && obj["mode"] !== void 0) {
+      return validationError(
+        `${methodName} does not support the 'mode' parameter.`,
+        "Remove the mode parameter or use search_entries instead."
+      );
+    }
+  }
+  if (EXACT_MATCH_SEARCH_METHODS.has(methodName) && args.length === 1 && isRecord(args[0])) {
+    const obj = { ...args[0] };
+    args[0] = obj;
+    if ("exact_match" in obj) {
+      const isFuzzy = obj["exact_match"] === false;
+      obj["fuzzy_match"] = isFuzzy;
+      if (methodName !== "cross_team_search" && methodName !== "crossTeamSearch") obj["auto_correct"] = isFuzzy;
+      delete obj["exact_match"];
+    } else if (obj["fuzzy_match"] === true && !("auto_correct" in obj)) {
+      if (methodName !== "cross_team_search" && methodName !== "crossTeamSearch") obj["auto_correct"] = true;
+    }
+    if (typeof obj["start_date"] === "string" && (obj["end_date"] === void 0 || obj["end_date"] === null || obj["end_date"] === "")) {
+      obj["end_date"] = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    }
+    if ((methodName === "team_search" || methodName === "teamSearch" || methodName === "team_search_by_date_range" || methodName === "teamSearchByDateRange") && obj["project_number"] == null) {
+      const tags = Array.isArray(obj["tags"]) ? obj["tags"] : void 0;
+      const entryType = typeof obj["entry_type"] === "string" ? obj["entry_type"] : void 0;
+      const isFlagSearch = Boolean(tags && tags.length > 0 && tags.every((t) => typeof t === "string" && t.startsWith("flag:"))) || entryType === "flag";
+      if (!isFlagSearch) {
+        const label = methodName.includes("date") ? "Cross-project team date range searches" : "Cross-project team searches";
+        return validationError(
+          `${label} are only permitted for flags. Provide a project_number or filter by entry_type="flag" or flag:* tags.`,
+          'Provide a project_number, or use tags starting with "flag:" or entry_type="flag"'
+        );
+      }
+    }
+  }
+  if (SINGLE_ID_METHODS.has(methodName)) {
+    const singleRes = applySingleIdInterception(methodName, args);
+    if ("error" in singleRes) return singleRes;
+    args = singleRes.args;
+  }
+  if ((methodName === "update_entry" || methodName === "updateEntry") && args.length === 2 && (typeof args[0] === "number" || typeof args[0] === "string") && isRecord(args[1])) {
+    const asNum = typeof args[0] === "string" ? parseInt(args[0], 10) : args[0];
+    if (!isNaN(asNum)) args = [{ entry_id: asNum, ...args[1] }];
+  }
+  return applyBatchAndMutationInterceptions(methodName, args);
+}
+function applySingleIdInterception(methodName, args) {
+  if (args.length === 0) {
+    return validationError(`${methodName} requires an 'entry_id' parameter.`, "Provide { entry_id: number } as the argument");
+  }
+  if (args.length !== 1) return { args };
+  if (Array.isArray(args[0])) {
+    return validationError(
+      `${methodName} only accepts a single entry. To process multiple entries, use the batch equivalent (e.g., batch_delete_entries).`,
+      "Use a batch method or pass a single object like { entry_id: number }"
+    );
+  }
+  if (isRecord(args[0])) {
+    const obj = { ...args[0] };
+    args[0] = obj;
+    if (["ids", "entry_ids", "entry_id", "id"].some((k) => Array.isArray(obj[k]))) {
+      return validationError(
+        `${methodName} only accepts a single entry_id. To process multiple entries, use the batch equivalent.`,
+        "Use a batch method (e.g. batch_delete_entries) or pass { entry_id: number }"
+      );
+    }
+    const idVal = obj["entry_id"] ?? obj["entryId"] ?? obj["id"] ?? obj["path"] ?? obj["keep"];
+    if (idVal === void 0) {
+      return validationError(`${methodName} requires an 'entry_id' parameter.`, "Provide { entry_id: number, ... } as the argument");
+    }
+    for (const k of ["path", "keep"]) {
+      if (obj[k] !== void 0 && obj["entry_id"] === void 0) {
+        obj["entry_id"] = obj[k];
+        Reflect.deleteProperty(obj, k);
+      }
+    }
+    if (["q", "query", "mode", "search"].some((k) => obj[k] !== void 0) && !["update_entry", "updateEntry", "team_update_entry", "teamUpdateEntry"].includes(methodName)) {
+      return validationError(
+        `${methodName} does not support q, query, search, or mode parameters. It operates on a single entry by entry_id.`,
+        "Remove these parameters. Provide only the entry_id."
+      );
+    }
+    if (typeof idVal === "string" && isNaN(parseInt(idVal, 10))) {
+      return validationError(
+        `${methodName} requires a numeric entry_id, but received a non-numeric string ('${idVal}'). Journal entries use auto-incrementing integer IDs.`,
+        "Provide a numeric ID."
+      );
+    }
+  } else if (typeof args[0] === "number" || typeof args[0] === "string") {
+    const asNum = typeof args[0] === "string" ? parseInt(args[0], 10) : args[0];
+    if (!isNaN(asNum)) {
+      args[0] = { entry_id: asNum };
+    } else {
+      return validationError(
+        `${methodName} requires a numeric entry_id, but received a non-numeric string ('${args[0]}'). Journal entries use auto-incrementing integer IDs.`,
+        "Provide a numeric ID."
+      );
+    }
+  }
+  return { args };
+}
+function applyBatchAndMutationInterceptions(methodName, args) {
+  if (["batch_create_entries", "batchCreateEntries", "team_batch_create_entries", "teamBatchCreateEntries"].includes(methodName) && args.length === 1) {
+    if (Array.isArray(args[0])) args[0] = { entries: args[0] };
+    else if (isRecord(args[0]) && !("entries" in args[0])) {
+      return validationError(`${methodName} requires an 'entries' array.`, "Provide { entries: [...] } as the argument");
+    }
+  }
+  if (["batch_update_entries", "batchUpdateEntries", "team_batch_update_entries", "teamBatchUpdateEntries"].includes(methodName) && args.length === 1) {
+    if (Array.isArray(args[0])) args[0] = { updates: args[0] };
+    else if (isRecord(args[0]) && !("updates" in args[0])) {
+      return validationError(`${methodName} requires an 'updates' array.`, "Provide { updates: [...] } as the argument");
+    }
+  }
+  if (["batch_delete_entries", "batchDeleteEntries", "team_batch_delete_entries", "teamBatchDeleteEntries"].includes(methodName)) {
+    if (args.length === 1 && typeof args[0] === "string") {
+      args[0] = { entry_ids: args[0].split(",").map((s) => parseInt(s.trim(), 10)).filter((n) => !isNaN(n)) };
+    } else if (args.length === 1 && Array.isArray(args[0])) {
+      if (args[0].some((id) => typeof id === "string")) {
+        return validationError(
+          "batch_delete_entries expects an array of numeric IDs, but received an array containing strings.",
+          "Ensure all IDs in the array are numbers. Use parseInt() if necessary."
+        );
+      }
+      args[0] = { entry_ids: args[0] };
+    } else if (args.length > 1 && args.every((a) => typeof a === "number")) {
+      args = [{ entry_ids: args }];
+    } else if (args.length === 1 && isRecord(args[0]) && !("entry_ids" in args[0])) {
+      return validationError(`${methodName} requires an 'entry_ids' array.`, "Provide { entry_ids: [...] } as the argument");
+    }
+  }
+  if (["update_entry", "updateEntry", "team_update_entry", "teamUpdateEntry"].includes(methodName) && args.length === 1 && isRecord(args[0])) {
+    const obj = { ...args[0] };
+    args[0] = obj;
+    if (obj["keep"] !== void 0 && obj["is_archived"] === void 0) {
+      obj["is_archived"] = obj["keep"] === false || obj["keep"] === 0 || obj["keep"] === "";
+      delete obj["keep"];
+    }
+    for (const alias of ["text", "message", "description"]) {
+      if (obj[alias] !== void 0 && obj["content"] === void 0) {
+        obj["content"] = obj[alias];
+        Reflect.deleteProperty(obj, alias);
+      }
+    }
+    if (["q", "query", "path", "mode", "search"].some((k) => obj[k] !== void 0)) {
+      return validationError(
+        `${methodName} does not support q, query, search, path, or mode parameters.`,
+        "Remove these parameters. Use entry_id and content to update the entry."
+      );
+    }
+  }
+  if (["delete_entry", "deleteEntry", "team_delete_entry", "teamDeleteEntry"].includes(methodName) && args.length === 1 && isRecord(args[0])) {
+    const obj = { ...args[0] };
+    args[0] = obj;
+    if (obj["version"] !== void 0 && obj["expected_version"] === void 0) {
+      obj["expected_version"] = obj["version"];
+      delete obj["version"];
+    }
+    if ((methodName === "delete_entry" || methodName === "deleteEntry") && obj["project_number"] !== void 0) {
+      delete obj["project_number"];
+    }
+  }
+  if (CREATE_METHODS.has(methodName) && args.length === 1 && isRecord(args[0])) {
+    const obj = { ...args[0] };
+    args[0] = obj;
+    if (isRecord(obj["entry"])) {
+      const nested = obj["entry"];
+      delete obj["entry"];
+      for (const [k, v] of Object.entries(nested)) {
+        if (obj[k] === void 0 && v !== void 0) obj[k] = v;
+      }
+    }
+    for (const aliasKey of [
+      "entry",
+      "text",
+      "message",
+      "description",
+      "body",
+      "instructions",
+      "details",
+      "notes",
+      "summary",
+      "markdown",
+      "post",
+      "journal_entry",
+      "journalEntry",
+      "entry_text",
+      "entryText"
+    ]) {
+      if (obj[aliasKey] !== void 0) {
+        if (obj["content"] === void 0 && typeof obj[aliasKey] === "string") obj["content"] = obj[aliasKey];
+        Reflect.deleteProperty(obj, aliasKey);
+      }
+    }
+    if (obj["auto_context"] !== void 0) {
+      if (typeof obj["auto_context"] === "object" && obj["auto_context"] !== null) {
+        try {
+          obj["auto_context"] = JSON.stringify(obj["auto_context"]);
+        } catch {
+          return validationError(
+            `${methodName}: auto_context could not be serialized to JSON. Ensure it is a plain object (e.g. { commits: ['<sha>'] }) or a valid JSON string.`,
+            "Pass auto_context as either a JSON string (e.g. JSON.stringify({ commits: [sha] })) or a plain serializable object."
+          );
+        }
+      } else if (typeof obj["auto_context"] !== "string") {
+        return validationError(
+          `${methodName}: auto_context must be a JSON string or plain object (received ${typeof obj["auto_context"]}).`,
+          'Pass auto_context as a JSON string, e.g. JSON.stringify({ commits: ["<sha>"] }), or as a plain object like { commits: ["<sha>"] }.'
+        );
+      }
+    }
+    if (["q", "query", "path", "mode", "keep", "search"].some((k) => obj[k] !== void 0)) {
+      return validationError(
+        `${methodName} does not support q, query, search, path, mode, or keep parameters. It creates a new journal entry.`,
+        'Remove these parameters. Ensure you are providing the "content" of the entry.'
+      );
+    }
+  }
+  if (SESSION_SUMMARY_METHODS.has(methodName) && args.length === 1 && isRecord(args[0])) {
+    const obj = { ...args[0] };
+    args[0] = obj;
+    const tags = Array.isArray(obj["tags"]) ? obj["tags"] : void 0;
+    const entryType = typeof obj["entry_type"] === "string" ? obj["entry_type"] : void 0;
+    if (typeof obj["content"] === "string" && (tags?.includes("session-summary") || entryType === "retrospective")) {
+      obj["content"] = healSessionSummaryContent(obj["content"], { normalizeSynonyms: true, usePeriodOnNone: false });
+    }
+  }
+  return { args };
+}
+
+// src/codemode/normalizers/github-and-backup-interceptions.ts
+var GITHUB_METHODS = [
+  "get_github_issues",
+  "getGithubIssues",
+  "get_github_prs",
+  "getGithubPrs",
+  "get_github_issue",
+  "getGithubIssue",
+  "get_github_pr",
+  "getGithubPr",
+  "get_github_context",
+  "getGithubContext",
+  "get_kanban_board",
+  "getKanbanBoard",
+  "move_kanban_item",
+  "moveKanbanItem",
+  "add_kanban_item",
+  "addKanbanItem",
+  "delete_kanban_item",
+  "deleteKanbanItem",
+  "create_github_issue_with_entry",
+  "createGithubIssueWithEntry",
+  "close_github_issue_with_entry",
+  "closeGithubIssueWithEntry",
+  "get_github_milestones",
+  "getGithubMilestones",
+  "get_github_milestone",
+  "getGithubMilestone",
+  "create_github_milestone",
+  "createGithubMilestone",
+  "update_github_milestone",
+  "updateGithubMilestone",
+  "delete_github_milestone",
+  "deleteGithubMilestone",
+  "get_repo_insights",
+  "getRepoInsights",
+  "get_copilot_reviews",
+  "getCopilotReviews"
+];
+var BACKUP_METHODS = [
+  "backup_journal",
+  "backupJournal",
+  "team_backup",
+  "teamBackup",
+  "list_backups",
+  "listBackups",
+  "team_list_backups",
+  "teamListBackups",
+  "restore_backup",
+  "restoreBackup",
+  "cleanup_backups",
+  "cleanupBackups"
+];
+function applyGithubAndBackupInterceptions(methodName, args) {
+  if (GITHUB_METHODS.includes(methodName) && args.length === 1 && isRecord(args[0])) {
+    const ghRes = applyGithubInterceptions(methodName, args[0]);
+    if ("error" in ghRes) return ghRes;
+    args[0] = ghRes.obj;
+  }
+  if (BACKUP_METHODS.includes(methodName) && args.length === 1 && isRecord(args[0])) {
+    const bkRes = applyBackupInterceptions(methodName, args[0]);
+    if ("error" in bkRes) return bkRes;
+    args[0] = bkRes.obj;
+  }
+  return { args };
+}
+function applyGithubInterceptions(methodName, rawObj) {
+  const obj = { ...rawObj };
+  for (const key of ["text", "message", "description"]) {
+    if (obj[key] !== void 0) {
+      if (methodName.includes("create_github_issue") || methodName.includes("createGithubIssue")) {
+        if (obj["body"] === void 0) {
+          obj["body"] = obj[key];
+          Reflect.deleteProperty(obj, key);
+        }
+      } else if (methodName.includes("create_github_milestone") || methodName.includes("createGithubMilestone") || methodName.includes("update_github_milestone") || methodName.includes("updateGithubMilestone")) {
+        if (obj["title"] === void 0) {
+          obj["title"] = obj[key];
+          Reflect.deleteProperty(obj, key);
+        }
+      } else if (methodName.includes("close_github_issue") || methodName.includes("closeGithubIssue")) {
+        if (obj["comment"] === void 0 && key !== "description") {
+          obj["comment"] = obj[key];
+          Reflect.deleteProperty(obj, key);
+        } else if (obj["resolution_notes"] === void 0 && key === "description") {
+          obj["resolution_notes"] = obj[key];
+          delete obj["description"];
+        }
+      }
+    }
+  }
+  const hasStateParam = methodName.includes("get_github_issues") || methodName.includes("getGithubIssues") || methodName.includes("get_github_prs") || methodName.includes("getGithubPrs") || methodName.includes("get_github_milestones") || methodName.includes("getGithubMilestones");
+  if (hasStateParam && obj["keep"] !== void 0 && obj["state"] === void 0) {
+    if (obj["keep"] === true) obj["state"] = "open";
+    else if (obj["keep"] === false) obj["state"] = "closed";
+    else if (typeof obj["keep"] === "string") obj["state"] = obj["keep"];
+    delete obj["keep"];
+  }
+  if (methodName.includes("get_kanban_board") || methodName.includes("getKanbanBoard")) {
+    for (const k of ["keep", "path"]) {
+      if (obj[k] !== void 0 && obj["project_number"] === void 0) {
+        obj["project_number"] = obj[k];
+        Reflect.deleteProperty(obj, k);
+      }
+    }
+  }
+  if (methodName.includes("move_kanban_item") || methodName.includes("moveKanbanItem")) {
+    if (obj["keep"] !== void 0 && obj["item_id"] === void 0) {
+      obj["item_id"] = obj["keep"];
+      delete obj["keep"];
+    }
+    if (obj["path"] !== void 0 && obj["target_status"] === void 0) {
+      obj["target_status"] = obj["path"];
+      delete obj["path"];
+    }
+  }
+  if (methodName.includes("add_kanban_item") || methodName.includes("addKanbanItem")) {
+    if (obj["keep"] !== void 0 && obj["issue_number"] === void 0) {
+      obj["issue_number"] = obj["keep"];
+      delete obj["keep"];
+    }
+  }
+  if (methodName.includes("delete_kanban_item") || methodName.includes("deleteKanbanItem")) {
+    if (obj["keep"] !== void 0 && obj["item_id"] === void 0) {
+      obj["item_id"] = obj["keep"];
+      delete obj["keep"];
+    }
+  }
+  if (methodName.includes("get_github_milestone") || methodName.includes("getGithubMilestone") || methodName.includes("update_github_milestone") || methodName.includes("updateGithubMilestone") || methodName.includes("delete_github_milestone") || methodName.includes("deleteGithubMilestone")) {
+    if (obj["keep"] !== void 0 && obj["milestone_number"] === void 0) {
+      obj["milestone_number"] = obj["keep"];
+      delete obj["keep"];
+    }
+  }
+  if (obj["mode"] !== void 0 && obj["summary_only"] === void 0) {
+    obj["summary_only"] = obj["mode"] === "summary";
+    delete obj["mode"];
+  }
+  if (hasStateParam && (obj["q"] !== void 0 || obj["query"] !== void 0 || obj["search"] !== void 0)) {
+    return {
+      error: {
+        success: false,
+        error: `${methodName} does not support search queries (q/query/search). It only supports listing by state (open/closed).`,
+        code: "VALIDATION_ERROR",
+        category: "validation",
+        suggestion: "Remove the query parameter to list items, or use GitHub directly for complex searches.",
+        recoverable: true
+      }
+    };
+  }
+  if ((methodName.includes("get_github_context") || methodName.includes("getGithubContext")) && obj["path"] !== void 0) {
+    return {
+      error: {
+        success: false,
+        error: "get_github_context does not take a 'path' parameter. It returns repository-wide context.",
+        code: "VALIDATION_ERROR",
+        category: "validation",
+        suggestion: "Remove the path parameter.",
+        recoverable: true
+      }
+    };
+  }
+  return { obj };
+}
+function applyBackupInterceptions(methodName, rawObj) {
+  const obj = { ...rawObj };
+  if (methodName.includes("backup_journal") || methodName.includes("backupJournal") || methodName.includes("team_backup") || methodName.includes("teamBackup")) {
+    if (obj["name"] === void 0) {
+      for (const k of ["description", "message", "text", "path", "q", "keep", "mode"]) {
+        if (obj[k] !== void 0 && obj["name"] === void 0) obj["name"] = obj[k];
+        Reflect.deleteProperty(obj, k);
+      }
+    }
+  }
+  if (methodName.includes("list_backups") || methodName.includes("listBackups") || methodName.includes("team_list_backups") || methodName.includes("teamListBackups")) {
+    if (obj["q"] !== void 0 || obj["query"] !== void 0 || obj["search"] !== void 0 || obj["text"] !== void 0 || obj["message"] !== void 0 || obj["description"] !== void 0 || obj["path"] !== void 0 || obj["keep"] !== void 0 || obj["mode"] !== void 0) {
+      return {
+        error: {
+          success: false,
+          error: "list_backups does not support search queries or other parameters. It lists all available backups.",
+          code: "VALIDATION_ERROR",
+          category: "validation",
+          suggestion: "Remove these parameters.",
+          recoverable: true
+        }
+      };
+    }
+    if (obj["limit"] !== void 0) {
+      return {
+        error: {
+          success: false,
+          error: "list_backups does not support a limit parameter.",
+          code: "VALIDATION_ERROR",
+          category: "validation",
+          suggestion: "Remove the limit parameter.",
+          recoverable: true
+        }
+      };
+    }
+  }
+  if (methodName.includes("restore_backup") || methodName.includes("restoreBackup")) {
+    if (obj["filename"] === void 0) {
+      for (const k of ["path", "file", "text", "message", "description", "q", "keep", "mode"]) {
+        if (obj[k] !== void 0 && obj["filename"] === void 0) obj["filename"] = obj[k];
+        Reflect.deleteProperty(obj, k);
+      }
+    }
+  }
+  if (methodName.includes("cleanup_backups") || methodName.includes("cleanupBackups")) {
+    if (obj["keep_count"] === void 0) {
+      for (const k of ["keep", "limit", "q", "mode", "text", "message", "description", "path"]) {
+        if (obj[k] !== void 0 && obj["keep_count"] === void 0) obj["keep_count"] = obj[k];
+        Reflect.deleteProperty(obj, k);
+      }
+    }
+  }
+  return { obj };
+}
+
+// src/codemode/normalizers/domain-tool-interceptions.ts
+var IO_METHODS = [
+  "export_entries",
+  "exportEntries",
+  "team_export_entries",
+  "teamExportEntries",
+  "export_markdown",
+  "exportMarkdown",
+  "team_export_markdown",
+  "teamExportMarkdown",
+  "import_markdown",
+  "importMarkdown",
+  "team_import_markdown",
+  "teamImportMarkdown",
+  "import_external",
+  "importExternal",
+  "team_import_external",
+  "teamImportExternal"
+];
+var ANALYTICS_METHODS = [
+  "get_statistics",
+  "getStatistics",
+  "get_cross_project_insights",
+  "getCrossProjectInsights",
+  "team_get_statistics",
+  "teamGetStatistics",
+  "team_get_cross_project_insights",
+  "teamGetCrossProjectInsights",
+  "get_collaboration_matrix",
+  "getCollaborationMatrix",
+  "team_get_collaboration_matrix",
+  "teamGetCollaborationMatrix"
+];
+function validationErr(error, suggestion) {
+  return { error: { success: false, error, code: "VALIDATION_ERROR", category: "validation", suggestion, recoverable: true } };
+}
+function remapKeys(obj, fromKeys, targetKey) {
+  for (const k of fromKeys) {
+    if (obj[k] !== void 0 && obj[targetKey] === void 0) {
+      obj[targetKey] = obj[k];
+      Reflect.deleteProperty(obj, k);
+    }
+  }
+}
+function hasAnyKey(obj, keys) {
+  return keys.some((k) => obj[k] !== void 0);
+}
+function applyDomainToolInterceptions(methodName, args) {
+  if (["update_configuration", "updateConfiguration", "config", "configure"].includes(methodName)) {
+    if (args.length === 1 && isRecord(args[0])) {
+      let obj = { ...args[0] };
+      if (isRecord(obj["config"])) {
+        obj = { ...obj, ...obj["config"] };
+        delete obj["config"];
+      }
+      args[0] = obj;
+      if (obj["update_notes"] !== void 0 || obj["notes"] !== void 0 || obj["text"] !== void 0 && obj["tool_filter"] === void 0 && obj["briefing"] === void 0) {
+        return validationErr(
+          "update_configuration is for changing server configuration (tool_filter, briefing). To create journal entries or update notes, use mj.core.createEntry({ ... }).",
+          "Use mj.core.createEntry({ content: '...', project_number: 1 }) instead."
+        );
+      }
+      const hasContextParam = ["maxTokens", "max_tokens", "temperature", "model", "top_p", "topP"].find((k) => k in obj);
+      if (hasContextParam !== void 0) {
+        return validationErr(
+          `Unrecognized key: "${hasContextParam}". update_configuration is for configuring the memory-journal-mcp server and does not support changing LLM context parameters.`,
+          `Remove '${hasContextParam}' from the payload. Only tool_filter and briefing preferences are supported.`
+        );
+      }
+    }
+  }
+  if (IO_METHODS.includes(methodName) && args.length === 1 && isRecord(args[0])) {
+    const ioRes = applyIoInterceptions(methodName, args[0]);
+    if ("error" in ioRes) return ioRes;
+    args[0] = ioRes.obj;
+  }
+  if (["team_get_vector_index_stats", "teamGetVectorIndexStats", "get_vector_index_stats", "getVectorIndexStats"].includes(methodName) && args.length === 1 && isRecord(args[0])) {
+    const obj = { ...args[0] };
+    args[0] = obj;
+    if (hasAnyKey(obj, ["q", "query", "search", "text", "message", "description", "path"])) {
+      return validationErr(`${methodName} does not support search queries. It returns overall index statistics.`, "Remove the search query parameter.");
+    }
+  }
+  if (["rebuild_vector_index", "rebuildVectorIndex", "team_rebuild_vector_index", "teamRebuildVectorIndex"].includes(methodName) && args.length === 1 && (typeof args[0] === "boolean" || typeof args[0] === "string" || typeof args[0] === "number")) {
+    args[0] = {};
+  }
+  if (["list_deleted_entries", "listDeletedEntries", "team_list_deleted_entries", "teamListDeletedEntries"].includes(methodName) && args.length === 1 && isRecord(args[0])) {
+    const obj = { ...args[0] };
+    args[0] = obj;
+    if (hasAnyKey(obj, ["q", "query", "search", "text", "message", "description", "path", "mode"])) {
+      return validationErr(`${methodName} does not support search queries, path, or mode. It returns all deleted entries.`, "Remove these parameters.");
+    }
+    remapKeys(obj, ["keep"], "limit");
+    if ((methodName === "list_deleted_entries" || methodName === "listDeletedEntries") && obj["project_number"] !== void 0) {
+      delete obj["project_number"];
+    }
+    if (obj["project_id"] !== void 0) delete obj["project_id"];
+  }
+  if (ANALYTICS_METHODS.includes(methodName) && args.length === 1 && isRecord(args[0])) {
+    const obj = { ...args[0] };
+    args[0] = obj;
+    if (hasAnyKey(obj, ["q", "query", "search", "text", "message", "description", "path", "keep", "mode"])) {
+      return validationErr(
+        `${methodName} does not support search queries, content parameters, or modes. It returns analytical data.`,
+        "Remove these parameters. Use search_entries or team_search if you want to find specific content."
+      );
+    }
+    if (methodName.includes("get_statistics") || methodName.includes("getStatistics")) {
+      const timeVal = obj["time"] ?? obj["timeframe"] ?? obj["period"];
+      if (timeVal !== void 0) {
+        if (obj["group_by"] === void 0 && typeof timeVal === "string") {
+          const lower = timeVal.toLowerCase();
+          obj["group_by"] = ["day", "week", "month"].includes(lower) ? lower : "month";
+        }
+        delete obj["time"];
+        delete obj["timeframe"];
+        delete obj["period"];
+      }
+    }
+    if ((methodName.includes("get_cross_project_insights") || methodName.includes("getCrossProjectInsights")) && obj["limit"] !== void 0) {
+      return validationErr("get_cross_project_insights does not accept a limit parameter. It analyzes all projects.", "Remove the limit parameter.");
+    }
+  }
+  const ghBkRes = applyGithubAndBackupInterceptions(methodName, args);
+  if ("error" in ghBkRes) return ghBkRes;
+  args = ghBkRes.args;
+  return applyMiscToolInterceptions(methodName, args);
+}
+function applyIoInterceptions(methodName, rawObj) {
+  const obj = { ...rawObj };
+  remapKeys(obj, ["keep"], "limit");
+  if (hasAnyKey(obj, ["q", "query", "text", "search", "message", "description"])) {
+    return validationErr(
+      `${methodName} does not support text search or content parameters. It only exports/imports data.`,
+      "To search for specific text, use search_entries (or team_search). Otherwise, remove the search/content parameters."
+    );
+  }
+  if (obj["mode"] !== void 0) {
+    return validationErr(`${methodName} does not support the 'mode' parameter.`, "Remove the mode parameter.");
+  }
+  if (["export_entries", "exportEntries", "team_export_entries", "teamExportEntries"].includes(methodName)) {
+    if (hasAnyKey(obj, ["path", "output_dir", "file"])) {
+      return validationErr(
+        "export_entries returns the exported data directly and does not write to disk.",
+        "Use export_markdown if you want to save files to a directory, or remove path/output_dir."
+      );
+    }
+  }
+  const isExportMd = methodName.includes("export_markdown") || methodName.includes("exportMarkdown") || methodName.includes("teamExportMarkdown") || methodName.includes("team_export_markdown");
+  const isExternal = methodName.includes("import_external") || methodName.includes("importExternal") || methodName.includes("teamImportExternal") || methodName.includes("team_import_external");
+  for (const key of ["path", "file", "filepath", "dir", "folder", "target", "source"]) {
+    if (obj[key] !== void 0) {
+      let didMap = false;
+      if (isExportMd) {
+        if (obj["output_dir"] === void 0) obj["output_dir"] = obj[key];
+        didMap = true;
+      } else if (methodName.toLowerCase().includes("import") && !(key === "source" && isExternal)) {
+        if (obj["source_dir"] === void 0) obj["source_dir"] = obj[key];
+        didMap = true;
+      }
+      if (didMap) Reflect.deleteProperty(obj, key);
+    }
+  }
+  if (isExternal) {
+    if (obj["url"] !== void 0 || obj["link"] !== void 0) {
+      return validationErr(
+        "import_external does not download from URLs. It imports from a local directory (source_dir).",
+        "Provide a local directory path in source_dir."
+      );
+    }
+    remapKeys(obj, ["format", "source"], "source_format");
+  }
+  return { obj };
+}
+function applyMiscToolInterceptions(methodName, args) {
+  if (["link_entries", "linkEntries", "team_link_entries", "teamLinkEntries"].includes(methodName) && args.length === 1 && isRecord(args[0])) {
+    const obj = { ...args[0] };
+    args[0] = obj;
+    remapKeys(obj, ["source", "from", "source_id", "from_id"], "from_entry_id");
+    remapKeys(obj, ["target", "to", "target_id", "to_id", "dest"], "to_entry_id");
+    remapKeys(obj, ["type", "rel"], "relationship_type");
+    remapKeys(obj, ["notes", "message", "text"], "description");
+  }
+  if (["get_recent_entries", "getRecentEntries", "team_get_recent", "teamGetRecent"].includes(methodName) && args.length === 1 && isRecord(args[0])) {
+    const obj = { ...args[0] };
+    args[0] = obj;
+    if (hasAnyKey(obj, ["q", "query", "search"])) {
+      return validationErr(
+        `${methodName} does not support search queries. It only returns the most recent entries.`,
+        "To search for specific text, use team_search (or search_entries) instead."
+      );
+    }
+    remapKeys(obj, ["keep"], "limit");
+  }
+  if (["list_tags", "listTags", "team_list_tags", "teamListTags"].includes(methodName) && args.length === 1 && isRecord(args[0])) {
+    const obj = { ...args[0] };
+    args[0] = obj;
+    if (hasAnyKey(obj, ["q", "query", "search", "path", "mode", "keep"])) {
+      return validationErr(`${methodName} does not support search queries, path, mode, or keep. It returns all tags.`, "Remove these parameters.");
+    }
+  }
+  if (["test_simple", "testSimple", "test_error_handling", "testErrorHandling"].includes(methodName) && args.length === 1 && isRecord(args[0])) {
+    const obj = { ...args[0] };
+    args[0] = obj;
+    remapKeys(obj, ["text", "description"], "message");
+    if (methodName === "test_error_handling" || methodName === "testErrorHandling") {
+      remapKeys(obj, ["type"], "error_type");
+    }
+  }
+  if (["merge_tags", "mergeTags", "team_merge_tags", "teamMergeTags"].includes(methodName) && args.length === 1 && isRecord(args[0])) {
+    const obj = { ...args[0] };
+    args[0] = obj;
+    if (obj["source_tags"] !== void 0 && obj["source_tag"] === void 0) {
+      obj["source_tag"] = Array.isArray(obj["source_tags"]) ? obj["source_tags"][0] : obj["source_tags"];
+      delete obj["source_tags"];
+    }
+    remapKeys(obj, ["old_tag", "from"], "source_tag");
+    remapKeys(obj, ["new_tag", "to"], "target_tag");
+    if (typeof obj["source_tag"] === "string" && obj["source_tag"].includes(",")) {
+      return validationErr(
+        "merge_tags only accepts a single source_tag string, not a comma-separated list.",
+        "Provide a single tag string for source_tag. To merge multiple tags, call this tool multiple times."
+      );
+    }
+  }
+  if ((methodName === "search_audit_log" || methodName === "searchAuditLog") && args.length === 1 && isRecord(args[0])) {
+    const obj = { ...args[0] };
+    args[0] = obj;
+    remapKeys(obj, ["keep"], "limit");
+    if (typeof obj["limit"] === "string") {
+      const parsed = parseInt(obj["limit"], 10);
+      if (!isNaN(parsed)) obj["limit"] = parsed;
+    }
+  }
+  if ([
+    "team_add_member",
+    "teamAddMember",
+    "team_update_member_role",
+    "teamUpdateMemberRole",
+    "team_remove_member",
+    "teamRemoveMember",
+    "team_get_member",
+    "teamGetMember"
+  ].includes(methodName) && args.length === 1 && isRecord(args[0])) {
+    const obj = { ...args[0] };
+    args[0] = obj;
+    remapKeys(obj, ["path", "target", "user", "name", "account", "username", "member"], "author");
+    remapKeys(obj, ["keep", "mode", "type", "level", "permission"], "role");
+  }
+  if ([
+    "team_add_author_alias",
+    "teamAddAuthorAlias",
+    "team_remove_author_alias",
+    "teamRemoveAuthorAlias",
+    "team_list_author_aliases",
+    "teamListAuthorAliases",
+    "team_resolve_author",
+    "teamResolveAuthor",
+    "team_consolidate_authors",
+    "teamConsolidateAuthors"
+  ].includes(methodName) && args.length === 1 && isRecord(args[0])) {
+    const obj = { ...args[0] };
+    args[0] = obj;
+    for (const key of ["q", "query", "search"]) {
+      if (obj[key] !== void 0) {
+        if (obj["canonical_author"] === void 0 && obj["author"] === void 0 && obj["alias"] === void 0) {
+          obj["canonical_author"] = obj[key];
+          obj["author"] = obj[key];
+          obj["alias"] = obj[key];
+        }
+        Reflect.deleteProperty(obj, key);
+      }
+    }
+    remapKeys(obj, ["text", "message", "description", "name", "from", "source"], "alias");
+    remapKeys(obj, ["target", "to", "canonical", "dest"], "canonical_author");
+    if (obj["author"] !== void 0 && obj["canonical_author"] === void 0 && obj["alias"] === void 0) {
+      obj["canonical_author"] = obj["author"];
+    }
+  }
+  return { args };
+}
+
+// src/codemode/param-normalizer.ts
+function applyArgInterceptions(methodName, args) {
+  const gitIntercept = applyGitInterceptions(methodName, args);
+  if (gitIntercept) return gitIntercept;
+  const genericRes = applyGenericInterceptions(methodName, args);
+  if ("error" in genericRes) return genericRes;
+  let currentArgs = genericRes.args;
+  const domainRes = applyDomainToolInterceptions(methodName, currentArgs);
+  if ("error" in domainRes) return domainRes;
+  currentArgs = domainRes.args;
+  const entrySearchRes = applyEntryAndSearchInterceptions(methodName, currentArgs);
+  if ("error" in entrySearchRes) return entrySearchRes;
+  return entrySearchRes;
+}
+
+export { ENTRY_TYPE_ALIASES, GROUP_EXAMPLES, GROUP_PREFIX_MAP, KEEP_PREFIX_GROUPS, METHOD_ALIASES, PARAM_ALIASES, POSITIONAL_PARAM_MAP, TAG_ALIASES, VERSION, applyArgInterceptions, healAutoContext, healSessionSummaryContent, isRecord, safeString };