memory-journal-mcp 9.0.0 → 9.1.0

package/dist/chunk-FZLB6NAV.js

@@ -0,0 +1,746 @@
+import { MAX_CONTENT_LENGTH, MAX_QUERY_LIMIT, resolveProjectContext, safeString, ENTRY_TYPES, coerceSignificanceAlias, SIGNIFICANCE_TYPES } from './chunk-D2FY6XS5.js';
+import { z } from 'zod';
+import * as crypto from 'crypto';
+import { Buffer } from 'buffer';
+
+// src/handlers/tools/schemas/hallucination-healer.ts
+var KEY_ALIAS_MAP = {
+  id: "entry_id",
+  ids: "entry_ids",
+  entryId: "entry_id",
+  project_id: "project_number",
+  projectId: "project_number",
+  projectNumber: "project_number",
+  project: "project_number",
+  workspaceId: "workspace_id",
+  workspace: "workspace_id",
+  repo: "workspace_id",
+  repository: "workspace_id",
+  repo_name: "workspace_id",
+  isPersonal: "is_personal",
+  personal: "is_personal",
+  entryType: "entry_type",
+  significanceType: "significance_type",
+  significance: "significance_type",
+  autoContext: "auto_context",
+  impactScore: "impact_score",
+  impact: "impact_score",
+  trustScore: "trust_score",
+  trust: "trust_score",
+  confidence: "trust_score",
+  validationStatus: "validation_status",
+  validation: "validation_status",
+  workflowRunId: "workflow_run_id",
+  workflowName: "workflow_name",
+  workflowStatus: "workflow_status",
+  prNumber: "pr_number",
+  prUrl: "pr_url",
+  prStatus: "pr_status",
+  issueNumber: "issue_number",
+  issueUrl: "issue_url",
+  projectOwner: "project_owner",
+  shareWithTeam: "share_with_team",
+  share_team: "share_with_team",
+  team: "share_with_team",
+  anchorPath: "anchor_path",
+  anchorType: "anchor_type",
+  sourceTag: "source_tag",
+  targetTag: "target_tag",
+  fromEntryId: "from_entry_id",
+  fromId: "from_entry_id",
+  toEntryId: "to_entry_id",
+  toId: "to_entry_id",
+  relationshipType: "relationship_type",
+  session: "session_id",
+  sessionId: "session_id",
+  conversation_id: "session_id",
+  conversationId: "session_id",
+  thread_id: "session_id",
+  threadId: "session_id"
+};
+var CONTENT_ALIASES = [
+  "entry",
+  "text",
+  "message",
+  "description",
+  "summary",
+  "notes",
+  "body",
+  "instructions",
+  "details",
+  "markdown",
+  "post",
+  "journal_entry",
+  "journalEntry",
+  "entry_text",
+  "entryText"
+];
+var PASSED_VALIDATION_ALIASES = /* @__PURE__ */ new Set([
+  "pass",
+  "success",
+  "ok",
+  "passed",
+  "validated",
+  "valid",
+  "verified",
+  "true",
+  "1"
+]);
+var FAILED_VALIDATION_ALIASES = /* @__PURE__ */ new Set(["fail", "failed", "error", "failing", "false", "0"]);
+var NONE_VALIDATION_ALIASES = /* @__PURE__ */ new Set([
+  "none",
+  "null",
+  "undefined",
+  "skip",
+  "skipped",
+  "unknown",
+  "pending"
+]);
+var SESSION_SUMMARY_TAG_ALIASES = /* @__PURE__ */ new Set([
+  "session summary",
+  "session_summary",
+  "team-session-summary",
+  "team_session_summary",
+  "team session summary"
+]);
+var TECHNICAL_NOTE_ALIASES = /* @__PURE__ */ new Set([
+  "task",
+  "chore",
+  "refactor",
+  "fix",
+  "update",
+  "technical",
+  "note",
+  "documentation",
+  "code",
+  "coding"
+]);
+var BUG_FIX_ALIASES = /* @__PURE__ */ new Set(["bug", "bugfix", "bug_fix", "bug-fix", "hotfix", "defect"]);
+function toStr(v) {
+  if (typeof v === "string") return v;
+  if (typeof v === "number" || typeof v === "boolean") return String(v);
+  if (v !== null && v !== void 0) {
+    try {
+      return JSON.stringify(v);
+    } catch {
+      return "";
+    }
+  }
+  return "";
+}
+function healMetadataAndContextFields(obj) {
+  let modified = false;
+  for (const extraKey of ["date", "created_at", "updated_at", "type", "status"]) {
+    if (extraKey in obj && extraKey !== "entry_type") {
+      if (extraKey === "type" && !("entry_type" in obj)) obj["entry_type"] = obj["type"];
+      Reflect.deleteProperty(obj, extraKey);
+      modified = true;
+    }
+  }
+  for (const [field, label] of [
+    ["context", "Context"],
+    ["focus", "Focus"],
+    ["resolution", "Resolution"]
+  ]) {
+    if (field in obj) {
+      const val = field === "context" && typeof obj[field] === "object" && obj[field] !== null ? JSON.stringify(obj[field], null, 2) : toStr(obj[field]);
+      if (val !== "") {
+        const existingContent = toStr(obj["content"]);
+        obj["content"] = existingContent !== "" ? `${existingContent}
+
+**${label}:** ${val}` : val;
+      }
+      Reflect.deleteProperty(obj, field);
+      modified = true;
+    }
+  }
+  if ("artifacts" in obj) {
+    if (Array.isArray(obj["artifacts"]) && obj["artifacts"].length > 0) {
+      const artStr = obj["artifacts"].map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(", ");
+      const existingContent = toStr(obj["content"]);
+      obj["content"] = existingContent !== "" ? `${existingContent}
+
+**Artifacts:** ${artStr}` : artStr;
+    }
+    Reflect.deleteProperty(obj, "artifacts");
+    modified = true;
+  }
+  if ("category" in obj) {
+    if (typeof obj["category"] === "string" && obj["category"].trim() !== "") {
+      const cat = obj["category"].trim();
+      obj["tags"] ??= [];
+      if (Array.isArray(obj["tags"]) && !obj["tags"].includes(cat)) obj["tags"].push(cat);
+    }
+    Reflect.deleteProperty(obj, "category");
+    modified = true;
+  }
+  return modified;
+}
+function healTagsAndEntryType(obj) {
+  let modified = false;
+  if ("tag" in obj && !("tags" in obj)) {
+    obj["tags"] = obj["tag"];
+    delete obj["tag"];
+    modified = true;
+  }
+  if ("tags" in obj && typeof obj["tags"] === "string") {
+    obj["tags"] = obj["tags"].split(",").map((t) => t.trim()).filter(Boolean);
+    modified = true;
+  }
+  if ("tags" in obj && Array.isArray(obj["tags"])) {
+    const healedTags = obj["tags"].map((t) => {
+      if (typeof t === "string") {
+        const lower = t.toLowerCase().trim();
+        if (SESSION_SUMMARY_TAG_ALIASES.has(lower)) return "session-summary";
+        if (lower === "commit narrative" || lower === "commit_narrative")
+          return "commit-narrative";
+      }
+      return t;
+    });
+    if (JSON.stringify(obj["tags"]) !== JSON.stringify(healedTags)) {
+      obj["tags"] = healedTags;
+      modified = true;
+    }
+  }
+  if ("entry_type" in obj && typeof obj["entry_type"] === "string") {
+    const etLower = obj["entry_type"].toLowerCase();
+    if (etLower === "session-summary" || SESSION_SUMMARY_TAG_ALIASES.has(etLower)) {
+      obj["entry_type"] = "retrospective";
+      obj["tags"] ??= [];
+      if (Array.isArray(obj["tags"]) && !obj["tags"].includes("session-summary")) {
+        obj["tags"].push("session-summary");
+      }
+      modified = true;
+    } else if (etLower === "progress" || etLower === "status" || etLower === "development") {
+      obj["entry_type"] = "development_note";
+      modified = true;
+    } else if (TECHNICAL_NOTE_ALIASES.has(etLower)) {
+      obj["entry_type"] = "technical_note";
+      obj["tags"] ??= [];
+      if (Array.isArray(obj["tags"]) && !obj["tags"].includes(etLower)) {
+        obj["tags"].push(etLower);
+      }
+      modified = true;
+    } else if (BUG_FIX_ALIASES.has(etLower)) {
+      obj["entry_type"] = "bug_fix";
+      modified = true;
+    } else if (etLower === "feature") {
+      obj["entry_type"] = "feature_implementation";
+      modified = true;
+    } else if (etLower === "meeting") {
+      obj["entry_type"] = "meeting_notes";
+      modified = true;
+    } else if (!ENTRY_TYPES.some((t) => t === obj["entry_type"])) {
+      obj["tags"] ??= [];
+      const cleanedTag = etLower.replace(/^[^a-z0-9]+/, "").replace(/_/g, "-");
+      if (Array.isArray(obj["tags"]) && cleanedTag.length > 0 && !obj["tags"].includes(cleanedTag)) {
+        obj["tags"].push(cleanedTag);
+      }
+      obj["entry_type"] = "other";
+      modified = true;
+    }
+  }
+  if ("significance_type" in obj) {
+    const originalSigType = obj["significance_type"];
+    coerceSignificanceAlias(obj);
+    if (typeof obj["significance_type"] === "string") {
+      if (!SIGNIFICANCE_TYPES.some((t) => t === obj["significance_type"])) {
+        const badSig = obj["significance_type"].toLowerCase().trim();
+        obj["tags"] ??= [];
+        if (Array.isArray(obj["tags"])) obj["tags"].push(`significance:${badSig}`);
+        delete obj["significance_type"];
+      }
+    }
+    if (originalSigType !== obj["significance_type"]) modified = true;
+  }
+  return modified;
+}
+function healWorkspaceAndProjectContext(obj) {
+  let modified = false;
+  const rawProjName = obj["project_name"] ?? obj["projectName"];
+  if (rawProjName !== void 0) {
+    if (!("project_number" in obj) || obj["project_number"] === void 0) {
+      const num = Number(rawProjName);
+      const strVal = typeof rawProjName === "string" || typeof rawProjName === "number" ? String(rawProjName) : "";
+      if (!Number.isNaN(num) && strVal.trim() !== "") obj["project_number"] = num;
+    }
+    delete obj["project_name"];
+    delete obj["projectName"];
+    modified = true;
+  }
+  if ("project_number" in obj && typeof obj["project_number"] === "string") {
+    const cleaned = obj["project_number"].trim();
+    let num = Number(cleaned);
+    if (Number.isNaN(num) && /^p-?\d+$/i.test(cleaned)) {
+      num = Number(cleaned.replace(/^p-?/i, ""));
+    }
+    if (!Number.isNaN(num) && cleaned !== "") {
+      obj["project_number"] = num;
+      modified = true;
+    } else {
+      if (obj["workspace_id"] === void 0 || obj["workspace_id"] === null || obj["workspace_id"] === "default") {
+        obj["workspace_id"] = cleaned;
+      }
+      delete obj["project_number"];
+      modified = true;
+    }
+  }
+  const wsId = typeof obj["workspace_id"] === "string" ? obj["workspace_id"] : void 0;
+  const projNum = typeof obj["project_number"] === "number" && !Number.isNaN(obj["project_number"]) ? obj["project_number"] : void 0;
+  const contentStr = typeof obj["content"] === "string" ? obj["content"] : void 0;
+  const tagsArr = Array.isArray(obj["tags"]) ? obj["tags"].filter((t) => typeof t === "string") : void 0;
+  if (wsId === void 0 || wsId === "" || wsId === "default" || projNum === void 0) {
+    const resolved = resolveProjectContext({
+      workspace_id: wsId,
+      project_number: projNum,
+      content: contentStr,
+      tags: tagsArr
+    });
+    if (resolved.workspaceId !== void 0 && resolved.workspaceId !== "default" && (wsId === void 0 || wsId === "default")) {
+      obj["workspace_id"] = resolved.workspaceId;
+      modified = true;
+    } else if (process.env["MCP_WORKSPACE_ID"] !== void 0 && process.env["MCP_WORKSPACE_ID"].trim() !== "" && (wsId === void 0 || wsId === "default")) {
+      obj["workspace_id"] = process.env["MCP_WORKSPACE_ID"].trim();
+      modified = true;
+    } else if (wsId === void 0) {
+      obj["workspace_id"] = "default";
+      modified = true;
+    }
+    if (obj["project_number"] === void 0 && resolved.projectNumber !== void 0) {
+      obj["project_number"] = resolved.projectNumber;
+      modified = true;
+    }
+  }
+  return modified;
+}
+function healTitleAndAutoContext(obj) {
+  let modified = false;
+  if ("title" in obj || "heading" in obj || "subject" in obj || "name" in obj) {
+    const rawTitle = obj["title"] ?? obj["heading"] ?? obj["subject"] ?? obj["name"];
+    if (rawTitle !== void 0 && rawTitle !== null) {
+      const titleStr = safeString(rawTitle).trim();
+      if (titleStr !== "") {
+        const cleanTitle = titleStr.replace(/^#+\s*/, "");
+        const currentContent = safeString(obj["content"]).trim();
+        if (!("content" in obj) || obj["content"] === void 0 || obj["content"] === null || currentContent === "") {
+          if (!("query" in obj)) obj["content"] = `# ${cleanTitle}`;
+        } else if (!currentContent.startsWith(`# ${cleanTitle}`)) {
+          obj["content"] = `# ${cleanTitle}
+
+${currentContent}`;
+        }
+      }
+    }
+    delete obj["title"];
+    delete obj["heading"];
+    delete obj["subject"];
+    delete obj["name"];
+    modified = true;
+  }
+  if ("auto_context" in obj) {
+    if (typeof obj["auto_context"] === "object" && obj["auto_context"] !== null) {
+      try {
+        obj["auto_context"] = JSON.stringify(obj["auto_context"]);
+        modified = true;
+      } catch {
+      }
+    }
+    if (typeof obj["auto_context"] === "string") {
+      const ac = obj["auto_context"].trim().toLowerCase();
+      if (ac === "none" || ac === "{}" || ac === '{"commits":[]}') {
+        delete obj["auto_context"];
+        modified = true;
+      } else if (ac.startsWith("{") && ac.includes("'")) {
+        try {
+          JSON.parse(obj["auto_context"]);
+        } catch {
+          try {
+            const fixed = obj["auto_context"].replace(/'/g, '"');
+            const parsed = JSON.parse(fixed);
+            obj["auto_context"] = JSON.stringify(parsed);
+            modified = true;
+          } catch {
+          }
+        }
+      }
+    }
+  }
+  return modified;
+}
+function healAgentHallucinations(val) {
+  if (typeof val !== "object" || val === null) return val;
+  const obj = { ...val };
+  let modified = false;
+  for (const [badKey, goodKey] of Object.entries(KEY_ALIAS_MAP)) {
+    if (badKey in obj) {
+      if (!(goodKey in obj) && obj[badKey] !== void 0) obj[goodKey] = obj[badKey];
+      Reflect.deleteProperty(obj, badKey);
+      modified = true;
+    }
+  }
+  for (const numField of ["trust_score", "impact_score"]) {
+    if (numField in obj && typeof obj[numField] === "string") {
+      const n = Number(obj[numField]);
+      if (!Number.isNaN(n)) {
+        obj[numField] = n;
+        modified = true;
+      }
+    }
+  }
+  if ("validation_status" in obj && obj["validation_status"] !== void 0 && obj["validation_status"] !== null) {
+    const rawVs = obj["validation_status"];
+    const vsStr = typeof rawVs === "string" ? rawVs.trim().toLowerCase() : typeof rawVs === "number" || typeof rawVs === "boolean" ? String(rawVs) : "";
+    if (rawVs === true || PASSED_VALIDATION_ALIASES.has(vsStr)) {
+      obj["validation_status"] = "passed";
+      modified = true;
+    } else if (rawVs === false || FAILED_VALIDATION_ALIASES.has(vsStr)) {
+      obj["validation_status"] = "failed";
+      modified = true;
+    } else if (NONE_VALIDATION_ALIASES.has(vsStr)) {
+      obj["validation_status"] = "none";
+    } else if (typeof rawVs === "string" && !["passed", "none", "failed"].includes(vsStr)) {
+      obj["validation_status"] = "none";
+      modified = true;
+    }
+  }
+  if (healWorkspaceAndProjectContext(obj)) modified = true;
+  if ("entry" in obj && typeof obj["entry"] === "object" && obj["entry"] !== null && !Array.isArray(obj["entry"])) {
+    const nested = obj["entry"];
+    Reflect.deleteProperty(obj, "entry");
+    for (const [k, v] of Object.entries(nested)) {
+      if (!(k in obj) && v !== void 0) obj[k] = v;
+    }
+    modified = true;
+  }
+  if ("entry" in obj) {
+    const entryVal = obj["entry"];
+    if (typeof entryVal === "number" || typeof entryVal === "string" && /^\d+$/.test(entryVal.trim()) && !("tags" in obj) && !("entry_type" in obj) && !("title" in obj)) {
+      if (!("entry_id" in obj)) {
+        obj["entry_id"] = typeof entryVal === "number" ? entryVal : Number(entryVal.trim());
+        modified = true;
+      }
+      Reflect.deleteProperty(obj, "entry");
+    }
+  }
+  for (const key of CONTENT_ALIASES) {
+    if (key in obj && !("content" in obj)) {
+      obj["content"] = obj[key];
+      Reflect.deleteProperty(obj, key);
+      modified = true;
+      break;
+    } else if (key in obj) {
+      Reflect.deleteProperty(obj, key);
+      modified = true;
+    }
+  }
+  if (healTitleAndAutoContext(obj)) modified = true;
+  if ("entry_id" in obj && typeof obj["entry_id"] === "string") {
+    const cleaned = obj["entry_id"].replace(/^[^0-9]+/, "");
+    const num = Number(cleaned);
+    if (!Number.isNaN(num) && cleaned.trim() !== "") {
+      obj["entry_id"] = num;
+      modified = true;
+    }
+  }
+  if ("entry_ids" in obj && Array.isArray(obj["entry_ids"])) {
+    const healedIds = obj["entry_ids"].map((id) => {
+      if (typeof id === "string") {
+        const cleaned = id.replace(/^[^0-9]+/, "");
+        const num = Number(cleaned);
+        return !Number.isNaN(num) && cleaned.trim() !== "" ? num : id;
+      }
+      return id;
+    });
+    if (JSON.stringify(obj["entry_ids"]) !== JSON.stringify(healedIds)) {
+      obj["entry_ids"] = healedIds;
+      modified = true;
+    }
+  }
+  if (healMetadataAndContextFields(obj)) modified = true;
+  if (healTagsAndEntryType(obj)) modified = true;
+  return modified ? obj : val;
+}
+var ErrorFieldsMixin = z.object({
+  error: z.string().optional().describe("Human-readable error message"),
+  code: z.string().optional().describe("Error code (e.g. VALIDATION_ERROR, INTERNAL_ERROR)"),
+  category: z.string().optional().describe("Error category (validation, query, connection, internal)"),
+  recoverable: z.boolean().optional().describe("Whether the error is recoverable"),
+  suggestion: z.string().optional().describe("Suggested fix for the error"),
+  aggregated_errors: z.array(z.object({ message: z.string() }).catchall(z.unknown())).optional().describe("Details of individual errors in a multi-step operation"),
+  details: z.record(z.string(), z.unknown()).optional().describe("Additional error context")
+});
+
+// src/handlers/tools/schemas/output-schemas.ts
+var BatchResultOutputSchema = z.object({
+  success: z.boolean().optional(),
+  count: z.number().optional(),
+  error: z.string().optional()
+}).extend(ErrorFieldsMixin.shape);
+var EntryOutputSchema = z.object({
+  id: z.number(),
+  content: z.string().max(MAX_CONTENT_LENGTH),
+  entryType: z.string(),
+  isPersonal: z.boolean(),
+  timestamp: z.string(),
+  tags: z.array(z.string()).optional(),
+  significanceType: z.string().nullable().optional(),
+  autoContext: z.string().nullable().optional().describe("@deprecated Use author and flagMetadata instead"),
+  author: z.string().nullable().optional(),
+  flagMetadata: z.record(z.string(), z.unknown()).nullable().optional(),
+  deletedAt: z.string().nullable().optional(),
+  isArchived: z.boolean().optional(),
+  projectNumber: z.number().nullable().optional(),
+  projectName: z.string().optional().describe("Injected repository or project name resolved from projectRegistry"),
+  projectOwner: z.string().nullable().optional(),
+  issueNumber: z.number().nullable().optional(),
+  issueUrl: z.string().nullable().optional(),
+  prNumber: z.number().nullable().optional(),
+  prUrl: z.string().nullable().optional(),
+  prStatus: z.string().nullable().optional(),
+  workflowRunId: z.number().nullable().optional(),
+  workflowName: z.string().nullable().optional(),
+  workflowStatus: z.string().nullable().optional(),
+  workspaceId: z.string().optional().describe("Workspace isolation identifier"),
+  source: z.enum(["personal", "team"]).optional(),
+  importanceScore: z.number().optional().describe("Importance score (0.0-1.0), present when sort_by=importance"),
+  trustScore: z.number().optional(),
+  impactScore: z.number().optional(),
+  validationStatus: z.string().optional(),
+  version: z.number().optional(),
+  sessionId: z.string().nullable().optional()
+}).extend(ErrorFieldsMixin.shape);
+var EntriesListOutputSchema = z.object({
+  entries: z.array(EntryOutputSchema).optional(),
+  count: z.number().optional(),
+  searchMode: z.string().optional(),
+  degraded: z.boolean().optional().describe(
+    "True if the search degraded to a slower fallback method due to infrastructure failure"
+  ),
+  next_cursor: z.string().optional().describe("Cursor for the next page of results"),
+  highlights: z.array(z.object({ id: z.number(), snippet: z.string() })).optional().describe("FTS5 search snippets when include_highlights is true"),
+  facets: z.object({
+    tags: z.array(z.object({ name: z.string(), count: z.number() })),
+    entryTypes: z.array(z.object({ name: z.string(), count: z.number() }))
+  }).optional().describe("Distribution counts when include_facets is true"),
+  suggestions: z.array(z.string()).optional().describe("Fuzzy matches when fuzzy_match=true and no exact results were found"),
+  correctedQuery: z.string().optional().describe("The corrected query when auto_correct=true and a confident match was found"),
+  success: z.boolean().optional(),
+  error: z.string().optional()
+}).extend(ErrorFieldsMixin.shape);
+var EntryRevisionOutputSchema = z.object({
+  id: z.number(),
+  entryId: z.number(),
+  revisionNumber: z.number(),
+  contentSnapshot: z.string(),
+  changedAt: z.string(),
+  changedBy: z.string().nullable().optional()
+}).extend(ErrorFieldsMixin.shape);
+z.object({
+  revisions: z.array(EntryRevisionOutputSchema).optional(),
+  count: z.number().optional(),
+  success: z.boolean().optional(),
+  error: z.string().optional()
+}).extend(ErrorFieldsMixin.shape);
+var RelationshipOutputSchema = z.object({
+  id: z.number(),
+  fromEntryId: z.number(),
+  toEntryId: z.number(),
+  relationshipType: z.string(),
+  description: z.string().nullable().optional(),
+  createdAt: z.string()
+}).extend(ErrorFieldsMixin.shape);
+var ImportanceBreakdownSchema = z.object({
+  significance: z.number(),
+  relationships: z.number(),
+  causal: z.number(),
+  recency: z.number(),
+  trustModifier: z.number().optional()
+});
+var TagOutputSchema = z.object({
+  name: z.string(),
+  count: z.number().nullable()
+}).extend(ErrorFieldsMixin.shape);
+function calcPerDbLimit(limit, hasTeamDb) {
+  return hasTeamDb ? Math.min(limit * 2, MAX_QUERY_LIMIT) : limit;
+}
+function mergeMultipleSources(sources, limit, sortBy = "timestamp") {
+  const seen = /* @__PURE__ */ new Set();
+  const merged = [];
+  const all = sources.flat().sort((a, b) => {
+    if (sortBy === "importance") {
+      const scoreA = Number(a["importanceScore"]) || 0;
+      const scoreB = Number(b["importanceScore"]) || 0;
+      if (scoreA !== scoreB) {
+        return scoreB - scoreA;
+      }
+    }
+    return b.timestamp.localeCompare(a.timestamp);
+  });
+  for (const entry of all) {
+    const entryId = typeof entry["id"] === "number" || typeof entry["id"] === "string" ? String(entry["id"]) : "";
+    const sourceKey = entry.team_db ? `${entry.source}:${entry.team_db}` : entry.source;
+    const key = entryId ? `${sourceKey}:${entryId}` : crypto.createHash("sha256").update(`${sourceKey}:${entry.content}`).digest("hex");
+    if (!seen.has(key)) {
+      seen.add(key);
+      merged.push(entry);
+    }
+  }
+  return limit !== void 0 ? merged.slice(0, limit) : merged;
+}
+function mergeAndDedup(personal, team, limit, sortBy = "timestamp") {
+  return mergeMultipleSources([personal, team], limit, sortBy);
+}
+function passMetadataFilters(entry, options, db) {
+  if (options.workspaceId !== void 0 && options.workspaceId !== "*" && entry.workspaceId !== options.workspaceId) {
+    return false;
+  }
+  if (options.isPersonal !== void 0 && entry.isPersonal !== options.isPersonal) return false;
+  if (options.projectNumber !== void 0 && entry.projectNumber !== options.projectNumber)
+    return false;
+  if (options.issueNumber !== void 0 && entry.issueNumber !== options.issueNumber) return false;
+  if (options.prNumber !== void 0 && entry.prNumber !== options.prNumber) return false;
+  if (options.prStatus !== void 0 && entry.prStatus !== options.prStatus) return false;
+  if (options.workflowRunId !== void 0 && entry.workflowRunId !== options.workflowRunId)
+    return false;
+  if (options.entryType && entry.entryType !== options.entryType) return false;
+  if (options.startDate) {
+    const entryDate = entry.timestamp.split("T")[0] ?? "";
+    if (entryDate < options.startDate) return false;
+  }
+  if (options.endDate) {
+    const entryDate = entry.timestamp.split("T")[0] ?? "";
+    if (entryDate > options.endDate) return false;
+  }
+  if (options.tags && options.tags.length > 0) {
+    const entryTags = Array.isArray(entry.tags) ? entry.tags : db.getTagsForEntry(entry.id);
+    if (!options.tags.some((t) => entryTags.includes(t))) return false;
+  }
+  if (!options.includeArchived && entry.isArchived) return false;
+  return true;
+}
+function encodeCompoundCursor(personalCursor, teamCursor) {
+  return Buffer.from(JSON.stringify({ p: personalCursor, t: teamCursor })).toString("base64");
+}
+function decodeCompoundCursor(cursor) {
+  try {
+    const decoded = Buffer.from(cursor, "base64").toString("utf8");
+    return JSON.parse(decoded);
+  } catch {
+    return null;
+  }
+}
+function ftsSearch(query, db, teamDb, options) {
+  const hasFilters = options.projectNumber !== void 0 || options.issueNumber !== void 0 || options.prNumber !== void 0 || options.prStatus !== void 0 || options.workflowRunId !== void 0 || options.isPersonal !== void 0 || options.tags !== void 0 || options.entryType !== void 0 || options.startDate !== void 0 || options.endDate !== void 0;
+  let personalCursor;
+  let teamCursor;
+  if (options.cursor) {
+    if (teamDb && options.includeTeam === true && options.isPersonal !== true) {
+      const compound = decodeCompoundCursor(options.cursor);
+      if (compound) {
+        personalCursor = compound.p;
+        teamCursor = compound.t;
+      } else {
+        personalCursor = options.cursor;
+      }
+    } else {
+      personalCursor = options.cursor;
+    }
+  }
+  const perDbLimit = calcPerDbLimit(options.limit, !!teamDb);
+  let personalResult;
+  if (!query && !hasFilters) {
+    personalResult = db.getRecentEntries(perDbLimit, options.isPersonal, options.sortBy, personalCursor, options.includeArchived, options.workspaceId);
+  } else {
+    personalResult = db.searchEntries(query || "", {
+      limit: perDbLimit,
+      cursor: personalCursor,
+      isPersonal: options.isPersonal,
+      projectNumber: options.projectNumber,
+      issueNumber: options.issueNumber,
+      prNumber: options.prNumber,
+      prStatus: options.prStatus,
+      workflowRunId: options.workflowRunId,
+      tags: options.tags,
+      entryType: options.entryType,
+      startDate: options.startDate,
+      endDate: options.endDate,
+      sortBy: options.sortBy,
+      includeHighlights: options.includeHighlights,
+      fuzzy_match: options.fuzzy_match,
+      auto_correct: options.auto_correct,
+      includeArchived: options.includeArchived,
+      workspaceId: options.workspaceId
+    });
+  }
+  const personalEntries = personalResult.entries;
+  const personalNextCursor = personalResult.nextCursor;
+  if (teamDb && options.includeTeam === true && options.isPersonal !== true) {
+    let teamResult;
+    if (!query && !hasFilters) {
+      teamResult = teamDb.getRecentEntries(perDbLimit, void 0, options.sortBy, teamCursor, options.includeArchived, options.workspaceId);
+    } else {
+      teamResult = teamDb.searchEntries(query || "", {
+        limit: perDbLimit,
+        cursor: teamCursor,
+        projectNumber: options.projectNumber,
+        issueNumber: options.issueNumber,
+        prNumber: options.prNumber,
+        prStatus: options.prStatus,
+        workflowRunId: options.workflowRunId,
+        tags: options.tags,
+        entryType: options.entryType,
+        startDate: options.startDate,
+        endDate: options.endDate,
+        sortBy: options.sortBy,
+        includeHighlights: options.includeHighlights,
+        fuzzy_match: options.fuzzy_match,
+        auto_correct: options.auto_correct,
+        includeArchived: options.includeArchived,
+        workspaceId: options.workspaceId
+      });
+    }
+    const teamEntries = teamResult.entries;
+    const teamNextCursor = teamResult.nextCursor;
+    const merged = mergeAndDedup(
+      personalEntries.map((e) => ({ ...e, source: "personal" })),
+      teamEntries.map((e) => ({ ...e, source: "team" })),
+      options.limit,
+      options.sortBy
+    );
+    let compoundNextCursor;
+    if (personalNextCursor || teamNextCursor) {
+      compoundNextCursor = encodeCompoundCursor(personalNextCursor, teamNextCursor);
+    }
+    const isTeamDegraded = "degraded" in teamResult && teamResult.degraded === true;
+    const isPersonalDegraded2 = "degraded" in personalResult && personalResult.degraded === true;
+    let mergedHighlights;
+    if (options.includeHighlights) {
+      const pHighlights = personalResult.highlights ?? [];
+      const tHighlights = teamResult.highlights ?? [];
+      if (pHighlights.length > 0 || tHighlights.length > 0) {
+        mergedHighlights = [...pHighlights, ...tHighlights];
+      }
+    }
+    return {
+      entries: merged,
+      count: merged.length,
+      degraded: isPersonalDegraded2 || isTeamDegraded,
+      nextCursor: compoundNextCursor,
+      highlights: mergedHighlights,
+      suggestions: personalResult.suggestions ?? teamResult.suggestions,
+      correctedQuery: personalResult.correctedQuery ?? teamResult.correctedQuery
+    };
+  }
+  const isPersonalDegraded = "degraded" in personalResult && personalResult.degraded === true;
+  return {
+    entries: personalEntries.map((e) => ({ ...e, source: "personal" })),
+    count: personalEntries.length,
+    degraded: isPersonalDegraded,
+    nextCursor: personalNextCursor,
+    highlights: personalResult.highlights,
+    suggestions: personalResult.suggestions,
+    correctedQuery: personalResult.correctedQuery
+  };
+}
+
+export { BatchResultOutputSchema, EntriesListOutputSchema, EntryOutputSchema, ErrorFieldsMixin, ImportanceBreakdownSchema, RelationshipOutputSchema, TagOutputSchema, calcPerDbLimit, decodeCompoundCursor, encodeCompoundCursor, ftsSearch, healAgentHallucinations, mergeAndDedup, mergeMultipleSources, passMetadataFilters };