@gethmy/mcp 2.3.2 → 2.3.3

package/dist/lib/context-assembly.js

@@ -1,1311 +0,0 @@
-import { createRequire } from "node:module";
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
-
-// ../memory/dist/schema.js
-var init_schema = () => {};
-
-// ../memory/dist/constraints.js
-var init_constraints = __esm(() => {
-  init_schema();
-});
-// ../memory/dist/client.js
-var init_client = __esm(() => {
-  init_constraints();
-});
-
-// ../memory/dist/graph-walk.js
-async function discoverRelatedContext(client, startIds, maxDepth = 2, maxEntities = 20, minConfidence = 0.5) {
-  const visited = new Set;
-  const collectedEntities = [];
-  const collectedRelations = [];
-  let truncated = false;
-  const queue = startIds.map((id) => [id, 0]);
-  for (const id of startIds) {
-    visited.add(id);
-  }
-  while (queue.length > 0) {
-    const [entityId, depth] = queue.shift();
-    if (collectedEntities.length >= maxEntities) {
-      truncated = true;
-      break;
-    }
-    if (depth > maxDepth)
-      continue;
-    try {
-      const entityResult = await client.getMemoryEntity(entityId);
-      const entity = entityResult.entity;
-      if (entity) {
-        collectedEntities.push({
-          id: entity.id,
-          type: entity.type,
-          title: entity.title,
-          confidence: entity.confidence ?? 1,
-          memory_tier: entity.memory_tier || "reference"
-        });
-      }
-      if (depth >= maxDepth)
-        continue;
-      const related = await client.getRelatedEntities(entityId);
-      for (const raw of related.outgoing || []) {
-        const rel = raw;
-        const relConfidence = rel.confidence ?? 1;
-        if (relConfidence < minConfidence)
-          continue;
-        const target = rel.target;
-        const targetId = target?.id ?? rel.target_id;
-        if (targetId && !visited.has(targetId)) {
-          visited.add(targetId);
-          queue.push([targetId, depth + 1]);
-          collectedRelations.push({
-            id: rel.id,
-            source_id: entityId,
-            target_id: targetId,
-            relation_type: rel.relation_type,
-            confidence: relConfidence
-          });
-        }
-      }
-      for (const raw of related.incoming || []) {
-        const rel = raw;
-        const relConfidence = rel.confidence ?? 1;
-        if (relConfidence < minConfidence)
-          continue;
-        const source = rel.source;
-        const sourceId = source?.id ?? rel.source_id;
-        if (sourceId && !visited.has(sourceId)) {
-          visited.add(sourceId);
-          queue.push([sourceId, depth + 1]);
-          collectedRelations.push({
-            id: rel.id,
-            source_id: sourceId,
-            target_id: entityId,
-            relation_type: rel.relation_type,
-            confidence: relConfidence
-          });
-        }
-      }
-    } catch {}
-  }
-  return {
-    entities: collectedEntities,
-    relations: collectedRelations,
-    depth: maxDepth,
-    truncated
-  };
-}
-
-// ../memory/dist/lifecycle.js
-function computeDecayScore(tier, lastAccessedAt, accessCount) {
-  const halfLife = DECAY_HALF_LIVES[tier];
-  const now = Date.now();
-  let daysSinceAccess = 0;
-  if (lastAccessedAt) {
-    daysSinceAccess = (now - new Date(lastAccessedAt).getTime()) / (1000 * 60 * 60 * 24);
-  }
-  const timeDecay = 0.5 ** (daysSinceAccess / halfLife);
-  const accessBonus = Math.log10(accessCount + 1) * 0.1;
-  const score = Math.min(timeDecay + accessBonus, 1);
-  return { score, daysSinceAccess, halfLife, accessBonus };
-}
-function checkPromotion(currentTier, accessCount, confidence, createdAt) {
-  const ageDays = (Date.now() - new Date(createdAt).getTime()) / (1000 * 60 * 60 * 24);
-  const base = {
-    eligible: false,
-    targetTier: null,
-    reason: null,
-    currentTier,
-    accessCount,
-    confidence,
-    ageDays
-  };
-  if (currentTier === "draft") {
-    const rules = PROMOTION_RULES.draftToEpisode;
-    if (accessCount >= rules.minAccessCount && confidence >= rules.minConfidence && ageDays >= rules.minAgeDays) {
-      return {
-        ...base,
-        eligible: true,
-        targetTier: "episode",
-        reason: `Accessed ${accessCount} times (≥${rules.minAccessCount}), confidence ${confidence} (≥${rules.minConfidence}), age ${Math.round(ageDays)}d (≥${rules.minAgeDays}d)`
-      };
-    }
-  }
-  if (currentTier === "episode") {
-    const rules = PROMOTION_RULES.episodeToReference;
-    if (accessCount >= rules.minAccessCount && confidence >= rules.minConfidence && ageDays >= rules.minAgeDays) {
-      return {
-        ...base,
-        eligible: true,
-        targetTier: "reference",
-        reason: `Accessed ${accessCount} times (≥${rules.minAccessCount}), confidence ${confidence} (≥${rules.minConfidence}), age ${Math.round(ageDays)}d (≥${rules.minAgeDays}d)`
-      };
-    }
-  }
-  return base;
-}
-function evaluateLifecycle(entity) {
-  const decay = computeDecayScore(entity.memory_tier, entity.last_accessed_at, entity.access_count);
-  const promotion = checkPromotion(entity.memory_tier, entity.access_count, entity.confidence, entity.created_at);
-  const shouldArchive = entity.confidence < ARCHIVE_THRESHOLD;
-  const archiveReason = shouldArchive ? `Confidence ${entity.confidence} below threshold ${ARCHIVE_THRESHOLD}` : undefined;
-  const shouldFlagForReview = decay.daysSinceAccess >= STALE_DAYS && entity.access_count < STALE_MIN_ACCESS;
-  const reviewReason = shouldFlagForReview ? `Not accessed in ${Math.round(decay.daysSinceAccess)} days with only ${entity.access_count} accesses` : undefined;
-  return {
-    decay,
-    promotion,
-    shouldArchive,
-    shouldFlagForReview,
-    archiveReason,
-    reviewReason
-  };
-}
-var DECAY_HALF_LIVES, PROMOTION_RULES, ARCHIVE_THRESHOLD = 0.3, STALE_DAYS = 90, STALE_MIN_ACCESS = 3;
-var init_lifecycle = __esm(() => {
-  DECAY_HALF_LIVES = {
-    draft: 7,
-    episode: 30,
-    reference: 180
-  };
-  PROMOTION_RULES = {
-    draftToEpisode: {
-      minAccessCount: 5,
-      minConfidence: 0.8,
-      minAgeDays: 1
-    },
-    episodeToReference: {
-      minAccessCount: 10,
-      minConfidence: 0.9,
-      minAgeDays: 7
-    }
-  };
-});
-
-// ../memory/dist/sync-storage.js
-function parseSyncMarkdown(markdown) {
-  const trimmed = markdown.trim();
-  let frontmatter = {
-    type: "context",
-    scope: "project",
-    tier: "reference",
-    confidence: 1,
-    tags: []
-  };
-  let body = trimmed;
-  const fmMatch = trimmed.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
-  if (fmMatch) {
-    frontmatter = parseSyncYamlFrontmatter(fmMatch[1]);
-    body = fmMatch[2].trim();
-  }
-  let title = "";
-  const titleMatch = body.match(/^#\s+(.+)/m);
-  if (titleMatch) {
-    title = titleMatch[1].trim();
-    body = body.replace(/^#\s+.+\n?/, "").trim();
-  }
-  return { frontmatter, title, content: body };
-}
-function serializeSyncMarkdown(entity) {
-  const lines = ["---"];
-  lines.push(`id: ${entity.id}`);
-  lines.push(`workspace_id: ${entity.workspace_id}`);
-  if (entity.project_id) {
-    lines.push(`project_id: ${entity.project_id}`);
-  }
-  lines.push(`type: ${entity.type}`);
-  lines.push(`scope: ${entity.scope}`);
-  lines.push(`tier: ${entity.memory_tier || "reference"}`);
-  lines.push(`confidence: ${entity.confidence}`);
-  if (entity.tags.length > 0) {
-    lines.push(`tags: [${entity.tags.join(", ")}]`);
-  } else {
-    lines.push("tags: []");
-  }
-  if (entity.agent_identifier) {
-    lines.push(`agent: ${entity.agent_identifier}`);
-  }
-  lines.push(`created_at: ${entity.created_at}`);
-  lines.push(`updated_at: ${entity.updated_at}`);
-  lines.push("---");
-  lines.push("");
-  lines.push(`# ${entity.title}`);
-  lines.push("");
-  lines.push(entity.content);
-  return lines.join(`
-`);
-}
-function parseSyncYamlFrontmatter(yaml) {
-  const result = {
-    type: "context",
-    scope: "project",
-    tier: "reference",
-    confidence: 1,
-    tags: []
-  };
-  for (const line of yaml.split(`
-`)) {
-    const colonIndex = line.indexOf(":");
-    if (colonIndex === -1)
-      continue;
-    const key = line.slice(0, colonIndex).trim();
-    const value = line.slice(colonIndex + 1).trim();
-    switch (key) {
-      case "id":
-        result.id = value;
-        break;
-      case "workspace_id":
-        result.workspace_id = value;
-        break;
-      case "project_id":
-        result.project_id = value;
-        break;
-      case "type":
-        result.type = value;
-        break;
-      case "scope":
-        result.scope = value;
-        break;
-      case "tier":
-        result.tier = value;
-        break;
-      case "confidence":
-        result.confidence = parseFloat(value) || 1;
-        break;
-      case "tags":
-        result.tags = parseYamlArray(value);
-        break;
-      case "related":
-        result.related = parseYamlArray(value);
-        break;
-      case "agent":
-        result.agent = value;
-        break;
-      case "created_at":
-        result.created_at = value;
-        break;
-      case "updated_at":
-        result.updated_at = value;
-        break;
-    }
-  }
-  return result;
-}
-function parseYamlArray(value) {
-  const match = value.match(/^\[(.*)]\s*$/);
-  if (!match)
-    return [];
-  return match[1].split(",").map((s) => s.trim()).filter(Boolean);
-}
-
-// ../memory/dist/sync.js
-import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { join, relative, sep } from "node:path";
-function computeFileHash(content) {
-  return `sha256:${createHash("sha256").update(content).digest("hex")}`;
-}
-function slugifyTitle(title) {
-  return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
-}
-function entityToFilename(entity) {
-  const slug = slugifyTitle(entity.title);
-  const shortId = entity.id.slice(0, 8);
-  return `${entity.type}--${slug}--${shortId}.md`;
-}
-function entityToDirectoryPath(entity, memoryDir) {
-  const wsDir = join(memoryDir, entity.workspace_id);
-  if (entity.scope === "private") {
-    return join(wsDir, "_private");
-  }
-  if (entity.scope === "workspace" || !entity.project_id) {
-    return join(wsDir, "_workspace");
-  }
-  return join(wsDir, entity.project_id);
-}
-function emptySyncState() {
-  return { version: 1, lastPullAt: null, entities: {} };
-}
-function loadSyncState(memoryDir) {
-  const statePath = join(memoryDir, ".sync-state.json");
-  if (!existsSync(statePath))
-    return emptySyncState();
-  try {
-    return JSON.parse(readFileSync(statePath, "utf-8"));
-  } catch {
-    return emptySyncState();
-  }
-}
-function saveSyncState(memoryDir, state) {
-  if (!existsSync(memoryDir)) {
-    mkdirSync(memoryDir, { recursive: true });
-  }
-  writeFileSync(join(memoryDir, ".sync-state.json"), JSON.stringify(state, null, 2));
-}
-function writeEntityFile(entity, memoryDir) {
-  const dir = entityToDirectoryPath(entity, memoryDir);
-  if (!existsSync(dir))
-    mkdirSync(dir, { recursive: true });
-  const filename = entityToFilename(entity);
-  const filePath = join(dir, filename);
-  const markdown = serializeSyncMarkdown(entity);
-  writeFileSync(filePath, markdown);
-  return relative(memoryDir, filePath);
-}
-function deleteEntityFile(relPath, memoryDir) {
-  const absPath = join(memoryDir, relPath);
-  if (existsSync(absPath)) {
-    rmSync(absPath);
-  }
-}
-function findMarkdownFiles(dir) {
-  const results = [];
-  if (!existsSync(dir))
-    return results;
-  for (const entry of readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = join(dir, entry.name);
-    if (entry.isDirectory()) {
-      results.push(...findMarkdownFiles(fullPath));
-    } else if (entry.isFile() && entry.name.endsWith(".md")) {
-      results.push(fullPath);
-    }
-  }
-  return results;
-}
-async function syncPull(client, config, workspaceId, projectId) {
-  const { memoryDir } = config;
-  const state = loadSyncState(memoryDir);
-  const result = {
-    pulled: 0,
-    pushed: 0,
-    deleted: 0,
-    conflicts: 0,
-    errors: []
-  };
-  const allEntities = [];
-  let offset = 0;
-  const batchSize = 100;
-  while (true) {
-    try {
-      const resp = await client.listMemoryEntities({
-        workspace_id: workspaceId,
-        project_id: projectId,
-        limit: batchSize,
-        offset
-      });
-      const batch = resp.entities;
-      allEntities.push(...batch);
-      if (batch.length < batchSize)
-        break;
-      offset += batchSize;
-    } catch (err) {
-      result.errors.push(`Failed to fetch entities: ${err}`);
-      return result;
-    }
-  }
-  const remoteIds = new Set(allEntities.map((e) => e.id));
-  for (const entity of allEntities) {
-    const existing = state.entities[entity.id];
-    const markdown = serializeSyncMarkdown(entity);
-    const hash = computeFileHash(markdown);
-    if (!existing) {
-      const relPath = writeEntityFile(entity, memoryDir);
-      state.entities[entity.id] = {
-        filePath: relPath,
-        remoteUpdatedAt: entity.updated_at,
-        lastSyncedHash: hash
-      };
-      result.pulled++;
-    } else {
-      const remoteChanged = entity.updated_at > existing.remoteUpdatedAt;
-      if (!remoteChanged)
-        continue;
-      const absPath = join(memoryDir, existing.filePath);
-      let localChanged = false;
-      if (existsSync(absPath)) {
-        const localContent = readFileSync(absPath, "utf-8");
-        const localHash = computeFileHash(localContent);
-        localChanged = localHash !== existing.lastSyncedHash;
-      }
-      if (localChanged) {
-        result.conflicts++;
-      }
-      const newRelPath = writeEntityFile(entity, memoryDir);
-      if (existing.filePath !== newRelPath) {
-        deleteEntityFile(existing.filePath, memoryDir);
-      }
-      state.entities[entity.id] = {
-        filePath: newRelPath,
-        remoteUpdatedAt: entity.updated_at,
-        lastSyncedHash: hash
-      };
-      result.pulled++;
-    }
-  }
-  for (const [entityId, entry] of Object.entries(state.entities)) {
-    if (!remoteIds.has(entityId)) {
-      deleteEntityFile(entry.filePath, memoryDir);
-      delete state.entities[entityId];
-      result.deleted++;
-    }
-  }
-  state.lastPullAt = new Date().toISOString();
-  saveSyncState(memoryDir, state);
-  return result;
-}
-async function syncPush(client, config, workspaceId) {
-  const { memoryDir } = config;
-  const state = loadSyncState(memoryDir);
-  const result = {
-    pulled: 0,
-    pushed: 0,
-    deleted: 0,
-    conflicts: 0,
-    errors: []
-  };
-  const mdFiles = findMarkdownFiles(memoryDir);
-  for (const absPath of mdFiles) {
-    const content = readFileSync(absPath, "utf-8");
-    const hash = computeFileHash(content);
-    const parsed = parseSyncMarkdown(content);
-    if (parsed.frontmatter.id) {
-      const entityId = parsed.frontmatter.id;
-      const existing = state.entities[entityId];
-      if (existing && hash === existing.lastSyncedHash)
-        continue;
-      try {
-        const resp = await client.updateMemoryEntity(entityId, {
-          title: parsed.title || "Untitled",
-          content: parsed.content,
-          type: parsed.frontmatter.type,
-          scope: parsed.frontmatter.scope,
-          confidence: parsed.frontmatter.confidence,
-          tags: parsed.frontmatter.tags
-        });
-        const updated = resp.entity;
-        const newMarkdown = serializeSyncMarkdown(updated);
-        writeFileSync(absPath, newMarkdown);
-        const relPath = relative(memoryDir, absPath);
-        state.entities[entityId] = {
-          filePath: relPath,
-          remoteUpdatedAt: updated.updated_at,
-          lastSyncedHash: computeFileHash(newMarkdown)
-        };
-        result.pushed++;
-      } catch (err) {
-        result.errors.push(`Failed to update ${entityId}: ${err}`);
-      }
-    } else {
-      const relPath = relative(memoryDir, absPath);
-      const parts = relPath.split(sep);
-      const fileWorkspaceId = parts.length >= 2 ? parts[0] : workspaceId;
-      let fileProjectId;
-      if (parts.length >= 3) {
-        const scopeDir = parts[1];
-        if (scopeDir !== "_workspace" && scopeDir !== "_private") {
-          fileProjectId = scopeDir;
-        }
-      }
-      let scope = parsed.frontmatter.scope || "project";
-      if (parts.length >= 3) {
-        const scopeDir = parts[1];
-        if (scopeDir === "_private")
-          scope = "private";
-        else if (scopeDir === "_workspace")
-          scope = "workspace";
-      }
-      try {
-        const resp = await client.createMemoryEntity({
-          workspace_id: fileWorkspaceId,
-          project_id: fileProjectId,
-          type: parsed.frontmatter.type,
-          scope,
-          title: parsed.title || "Untitled",
-          content: parsed.content,
-          confidence: parsed.frontmatter.confidence,
-          tags: parsed.frontmatter.tags,
-          agent_identifier: parsed.frontmatter.agent
-        });
-        const created = resp.entity;
-        const dir = entityToDirectoryPath(created, memoryDir);
-        if (!existsSync(dir))
-          mkdirSync(dir, { recursive: true });
-        const newFilename = entityToFilename(created);
-        const newAbsPath = join(dir, newFilename);
-        const newMarkdown = serializeSyncMarkdown(created);
-        writeFileSync(newAbsPath, newMarkdown);
-        if (absPath !== newAbsPath && existsSync(absPath)) {
-          rmSync(absPath);
-        }
-        const newRelPath = relative(memoryDir, newAbsPath);
-        state.entities[created.id] = {
-          filePath: newRelPath,
-          remoteUpdatedAt: created.updated_at,
-          lastSyncedHash: computeFileHash(newMarkdown)
-        };
-        result.pushed++;
-      } catch (err) {
-        result.errors.push(`Failed to create entity from ${relPath}: ${err}`);
-      }
-    }
-  }
-  saveSyncState(memoryDir, state);
-  return result;
-}
-async function syncFull(client, config, workspaceId, projectId) {
-  const pullResult = await syncPull(client, config, workspaceId, projectId);
-  const pushResult = await syncPush(client, config, workspaceId);
-  return {
-    pulled: pullResult.pulled,
-    pushed: pushResult.pushed,
-    deleted: pullResult.deleted,
-    conflicts: pullResult.conflicts,
-    errors: [...pullResult.errors, ...pushResult.errors]
-  };
-}
-var init_sync = () => {};
-
-// ../memory/dist/index.js
-var init_dist = __esm(() => {
-  init_client();
-  init_constraints();
-  init_lifecycle();
-  init_schema();
-  init_sync();
-});
-
-// src/context-assembly.ts
-var exports_context_assembly = {};
-__export(exports_context_assembly, {
-  trackSessionAssembly: () => trackSessionAssembly,
-  recordContextFeedback: () => recordContextFeedback,
-  mapToContextEntity: () => mapToContextEntity,
-  getSessionAssemblyId: () => getSessionAssemblyId,
-  getCachedManifest: () => getCachedManifest,
-  expandQuery: () => expandQuery,
-  computeRelevanceScore: () => computeRelevanceScore,
-  cacheManifest: () => cacheManifest,
-  assembleContext: () => assembleContext
-});
-function estimateTokens(text) {
-  return Math.ceil(text.length / 4);
-}
-function passesQualityGate(entity) {
-  const content = entity.content.trim();
-  if (content.length < 50)
-    return false;
-  const normalizedTitle = entity.title.toLowerCase().replace(/[^a-z0-9\s]/g, "").trim();
-  const normalizedContent = content.toLowerCase().replace(/[^a-z0-9\s]/g, "").trim();
-  if (normalizedContent.length < normalizedTitle.length * 1.5) {
-    return false;
-  }
-  if (entity.type === "pattern" && /recurring .+ \(\d+ instances\)/i.test(entity.title)) {
-    const lines = content.split(`
-`).filter((l) => l.trim().length > 0);
-    const bulletLines = lines.filter((l) => l.trim().startsWith("- "));
-    if (bulletLines.length > lines.length * 0.6)
-      return false;
-  }
-  if (entity.type === "procedure") {
-    const stepCount = (content.match(/^\d+\.\s/gm) || []).length;
-    if (stepCount < 3)
-      return false;
-  }
-  return true;
-}
-function generateAssemblyId() {
-  return `ctx_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 8)}`;
-}
-function truncateContent(content, maxTokens) {
-  const currentTokens = estimateTokens(content);
-  if (currentTokens <= maxTokens) {
-    return { text: content, truncated: false };
-  }
-  const paragraphs = content.split(/\n\n+/);
-  let result = paragraphs[0];
-  for (let i = 1;i < paragraphs.length; i++) {
-    const lines = paragraphs[i].split(`
-`).filter((l) => l.startsWith("- ") || l.startsWith("* "));
-    if (lines.length > 0) {
-      const bulletSection = lines.join(`
-`);
-      if (estimateTokens(result + `
-
-` + bulletSection) <= maxTokens) {
-        result += `
-
-` + bulletSection;
-      }
-    }
-  }
-  if (estimateTokens(result) > maxTokens) {
-    const maxChars = maxTokens * 4;
-    result = result.slice(0, maxChars - 3) + "...";
-  }
-  return { text: result, truncated: true };
-}
-function escapeRegex(str) {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function expandQuery(taskContext) {
-  const queries = [taskContext];
-  const lowerQueries = [taskContext.toLowerCase()];
-  const words = taskContext.toLowerCase().split(/\W+/).filter((w) => w.length > 2);
-  const expandableWords = words.filter((w) => QUERY_SYNONYMS[w]);
-  for (const word of expandableWords) {
-    const synonyms = QUERY_SYNONYMS[word];
-    if (!synonyms)
-      continue;
-    const variation = taskContext.replace(new RegExp(`\\b${escapeRegex(word)}\\b`, "gi"), synonyms[0]);
-    const lowerVariation = variation.toLowerCase();
-    if (lowerVariation !== taskContext.toLowerCase() && !lowerQueries.includes(lowerVariation)) {
-      queries.push(variation);
-      lowerQueries.push(lowerVariation);
-    }
-    if (queries.length >= MAX_QUERY_VARIATIONS)
-      break;
-  }
-  if (words.length >= 3) {
-    const keyPhrases = words.filter((w) => ![
-      "the",
-      "and",
-      "for",
-      "with",
-      "this",
-      "that",
-      "from",
-      "into"
-    ].includes(w)).slice(0, 4).join(" ");
-    if (!lowerQueries.includes(keyPhrases)) {
-      queries.push(keyPhrases);
-    }
-  }
-  return queries.slice(0, MAX_QUERY_VARIATIONS);
-}
-function computeRelevanceScore(entity, taskContext, cardLabels, graphRelations) {
-  const reasons = [];
-  let score = 0;
-  const hasRrfScore = entity.rrf_score !== undefined && entity.rrf_score > 0;
-  if (hasRrfScore) {
-    const normalizedRrf = Math.min(entity.rrf_score / 0.04, 1);
-    const rrfContribution = normalizedRrf * 0.3;
-    score += rrfContribution;
-    reasons.push(`hybrid_search(rrf=${entity.rrf_score.toFixed(4)})`);
-  }
-  const textMatchWeight = hasRrfScore ? 0.15 : 0.4;
-  const taskWords = new Set(taskContext.toLowerCase().split(/\W+/).filter((w) => w.length > 2));
-  const entityWords = new Set(`${entity.title} ${entity.content}`.toLowerCase().split(/\W+/).filter((w) => w.length > 2));
-  const overlap = [...taskWords].filter((w) => entityWords.has(w));
-  if (overlap.length > 0) {
-    const textScore = Math.min(overlap.length / Math.max(taskWords.size, 1), 1) * textMatchWeight;
-    score += textScore;
-    reasons.push(`text_match(${overlap.length} words)`);
-  }
-  if (cardLabels.length > 0 && entity.tags.length > 0) {
-    const labelSet = new Set(cardLabels.map((l) => l.toLowerCase()));
-    const tagOverlap = entity.tags.filter((t) => labelSet.has(t.toLowerCase()));
-    if (tagOverlap.length > 0) {
-      const tagScore = tagOverlap.length / cardLabels.length * 0.3;
-      score += tagScore;
-      reasons.push(`tag_match(${tagOverlap.join(",")})`);
-    }
-  }
-  score += entity.confidence * 0.15;
-  if (entity.confidence >= 0.9) {
-    reasons.push("high_confidence");
-  }
-  if (entity.last_accessed_at) {
-    const daysSinceAccess = (Date.now() - new Date(entity.last_accessed_at).getTime()) / (1000 * 60 * 60 * 24);
-    const halfLife = { draft: 7, episode: 30, reference: 180 }[entity.memory_tier];
-    const recencyScore = 0.5 ** (daysSinceAccess / halfLife) * 0.1;
-    score += recencyScore;
-    if (daysSinceAccess < 7)
-      reasons.push("recently_accessed");
-  }
-  if (entity.access_count > 0) {
-    const freqScore = Math.log10(entity.access_count + 1) * 0.05;
-    score += Math.min(freqScore, 0.1);
-    if (entity.access_count >= 5)
-      reasons.push(`frequently_used(${entity.access_count})`);
-  }
-  const usefulnessScore = entity.metadata?.usefulness_score ?? 0;
-  if (usefulnessScore >= 3) {
-    const usefulnessBoost = Math.min(usefulnessScore / 20, 0.15);
-    score += usefulnessBoost;
-    reasons.push(`useful(${usefulnessScore})`);
-  } else if (usefulnessScore === 0 && entity.access_count >= 5) {
-    score -= 0.02;
-    reasons.push("low_usefulness");
-  }
-  if (entity.type === "procedure") {
-    score += 0.1;
-    reasons.push("procedure_boost");
-  }
-  if (graphRelations && graphRelations.length > 0) {
-    const entityRelations = graphRelations.filter((r) => r.source_id === entity.id || r.target_id === entity.id);
-    if (entityRelations.length > 0) {
-      let bestBonus = 0;
-      let bestRelType = "";
-      for (const rel of entityRelations) {
-        const bonus = RELATION_BONUSES[rel.relation_type] ?? 0.1;
-        if (bonus > bestBonus) {
-          bestBonus = bonus;
-          bestRelType = rel.relation_type;
-        }
-      }
-      score += bestBonus;
-      reasons.push(`graph_walk(${bestRelType})`);
-    }
-  }
-  score = Math.max(0, Math.min(score, 1));
-  const tierWeight = TIER_WEIGHTS[entity.memory_tier];
-  score *= tierWeight;
-  return { score, reasons };
-}
-async function assembleContext(options) {
-  const {
-    workspaceId,
-    projectId,
-    taskContext,
-    cardLabels = [],
-    tokenBudget = DEFAULT_TOKEN_BUDGET,
-    client: client2,
-    graphWalkEnabled = true,
-    queryExpansionEnabled = true,
-    enableLlmReranking = false,
-    rerankFn
-  } = options;
-  const assemblyId = generateAssemblyId();
-  const manifest = {
-    assemblyId,
-    timestamp: new Date().toISOString(),
-    included: [],
-    excluded: [],
-    budgetUsed: 0,
-    budgetTotal: tokenBudget,
-    tierBreakdown: {
-      draft: { count: 0, tokens: 0 },
-      episode: { count: 0, tokens: 0 },
-      reference: { count: 0, tokens: 0 }
-    }
-  };
-  const candidates = [];
-  const queries = queryExpansionEnabled ? expandQuery(taskContext) : [taskContext];
-  const searchResults = await Promise.allSettled(queries.map((query) => client2.searchMemoryEntities(workspaceId, query, {
-    project_id: projectId,
-    limit: 30
-  })));
-  const candidateIds = new Set;
-  for (const result of searchResults) {
-    if (result.status !== "fulfilled")
-      continue;
-    if (result.value.entities?.length > 0) {
-      for (const raw of result.value.entities) {
-        const entity = mapToContextEntity(raw);
-        if (!candidateIds.has(entity.id)) {
-          candidateIds.add(entity.id);
-          candidates.push(entity);
-        }
-      }
-    }
-  }
-  if (candidates.length < 10 && projectId) {
-    try {
-      const listResult = await client2.listMemoryEntities({
-        workspace_id: workspaceId,
-        project_id: projectId,
-        limit: 30
-      });
-      if (listResult.entities?.length > 0) {
-        for (const raw of listResult.entities) {
-          const entity = mapToContextEntity(raw);
-          if (!candidateIds.has(entity.id)) {
-            candidateIds.add(entity.id);
-            candidates.push(entity);
-          }
-        }
-      }
-    } catch {}
-  }
-  if (candidates.length < 20) {
-    try {
-      const wsResult = await client2.listMemoryEntities({
-        workspace_id: workspaceId,
-        scope: "workspace",
-        limit: 20
-      });
-      if (wsResult.entities?.length > 0) {
-        for (const raw of wsResult.entities) {
-          const entity = mapToContextEntity(raw);
-          if (!candidateIds.has(entity.id)) {
-            candidateIds.add(entity.id);
-            candidates.push(entity);
-          }
-        }
-      }
-    } catch {}
-  }
-  let graphRelations = [];
-  if (graphWalkEnabled && candidates.length > 0) {
-    try {
-      const seedCandidates = [...candidates].sort((a, b) => (b.rrf_score ?? 0) - (a.rrf_score ?? 0)).slice(0, GRAPH_WALK_SEED_COUNT);
-      const seedIds = seedCandidates.map((c) => c.id);
-      const walkResult = await discoverRelatedContext(client2, seedIds, GRAPH_WALK_MAX_DEPTH, GRAPH_WALK_MAX_ENTITIES, GRAPH_WALK_MIN_CONFIDENCE);
-      graphRelations = walkResult.relations;
-      const newEntityIds = walkResult.entities.filter((e) => !candidateIds.has(e.id)).map((e) => e.id);
-      if (newEntityIds.length > 0) {
-        const fetchResults = await Promise.allSettled(newEntityIds.map((id) => client2.getMemoryEntity(id)));
-        for (const result of fetchResults) {
-          if (result.status !== "fulfilled" || !result.value.entity)
-            continue;
-          const mapped = mapToContextEntity(result.value.entity);
-          candidateIds.add(mapped.id);
-          candidates.push(mapped);
-        }
-      }
-    } catch {}
-  }
-  if (candidates.length === 0) {
-    return {
-      context: "",
-      manifest,
-      memories: []
-    };
-  }
-  const qualityCandidates = candidates.filter((entity) => {
-    if (passesQualityGate(entity))
-      return true;
-    manifest.excluded.push({
-      entityId: entity.id,
-      title: entity.title,
-      type: entity.type,
-      tier: entity.memory_tier,
-      relevanceScore: 0,
-      reason: "failed_quality_gate"
-    });
-    return false;
-  });
-  if (qualityCandidates.length === 0) {
-    return {
-      context: "",
-      manifest,
-      memories: []
-    };
-  }
-  const scored = qualityCandidates.map((entity) => {
-    const { score, reasons } = computeRelevanceScore(entity, taskContext, cardLabels, graphRelations.length > 0 ? graphRelations : undefined);
-    return { entity, score, reasons };
-  });
-  scored.sort((a, b) => b.score - a.score);
-  if (enableLlmReranking && rerankFn && scored.length >= RERANK_MIN_CANDIDATES) {
-    const topN = scored.slice(0, RERANK_TOP_N);
-    const scoreRange = topN[0].score - topN[topN.length - 1].score;
-    if (scoreRange <= RERANK_CLUSTER_THRESHOLD) {
-      try {
-        const rerankCandidates = topN.map((s) => ({
-          id: s.entity.id,
-          title: s.entity.title,
-          snippet: s.entity.content.slice(0, 200)
-        }));
-        const rerankedIds = await rerankFn(taskContext, rerankCandidates);
-        const idOrder = new Map(rerankedIds.map((id, i) => [id, i]));
-        topN.sort((a, b) => {
-          const aIdx = idOrder.get(a.entity.id) ?? 999;
-          const bIdx = idOrder.get(b.entity.id) ?? 999;
-          return aIdx - bIdx;
-        });
-        scored.splice(0, topN.length, ...topN);
-      } catch {}
-    }
-  }
-  const procedureBudget = Math.floor(tokenBudget * PROCEDURE_BUDGET_FRACTION);
-  const remainingBudget = tokenBudget - procedureBudget;
-  const tierBudgets = {
-    reference: Math.floor(remainingBudget * TIER_BUDGET_ALLOCATION.reference),
-    episode: Math.floor(remainingBudget * TIER_BUDGET_ALLOCATION.episode),
-    draft: Math.floor(remainingBudget * TIER_BUDGET_ALLOCATION.draft)
-  };
-  const tierUsed = {
-    reference: 0,
-    episode: 0,
-    draft: 0
-  };
-  let procedureUsed = 0;
-  const included = [];
-  let totalUsed = 0;
-  let referenceCount = 0;
-  for (const item of scored) {
-    if (item.entity.memory_tier === "reference" && item.entity.type !== "procedure" && referenceCount < MIN_REFERENCE_SLOTS) {
-      const { text, truncated } = truncateContent(item.entity.content, MAX_TOKENS_PER_ENTITY);
-      const tokens = estimateTokens(`### ${item.entity.title}
-${text}`);
-      if (totalUsed + tokens <= tokenBudget) {
-        included.push({ ...item, tokens, truncated });
-        item.entity.content = text;
-        totalUsed += tokens;
-        tierUsed.reference += tokens;
-        referenceCount++;
-      }
-    }
-  }
-  const includedIds = new Set(included.map((i) => i.entity.id));
-  const procedureCandidates = scored.filter((item) => item.entity.type === "procedure" && !includedIds.has(item.entity.id));
-  for (const item of procedureCandidates) {
-    if (item.score < MIN_RELEVANCE_THRESHOLD) {
-      manifest.excluded.push({
-        entityId: item.entity.id,
-        title: item.entity.title,
-        type: item.entity.type,
-        tier: item.entity.memory_tier,
-        relevanceScore: item.score,
-        reason: "below_relevance_threshold"
-      });
-      continue;
-    }
-    const { text, truncated } = truncateContent(item.entity.content, MAX_TOKENS_PER_ENTITY);
-    const tokens = estimateTokens(`### ${item.entity.title}
-${text}`);
-    if (procedureUsed + tokens > procedureBudget) {
-      const totalRemaining = tokenBudget - totalUsed;
-      if (tokens > totalRemaining) {
-        manifest.excluded.push({
-          entityId: item.entity.id,
-          title: item.entity.title,
-          type: item.entity.type,
-          tier: item.entity.memory_tier,
-          relevanceScore: item.score,
-          reason: "procedure_budget_exceeded"
-        });
-        continue;
-      }
-    }
-    if (totalUsed + tokens > tokenBudget) {
-      manifest.excluded.push({
-        entityId: item.entity.id,
-        title: item.entity.title,
-        type: item.entity.type,
-        tier: item.entity.memory_tier,
-        relevanceScore: item.score,
-        reason: "total_budget_exceeded"
-      });
-      continue;
-    }
-    included.push({ ...item, tokens, truncated });
-    item.entity.content = text;
-    totalUsed += tokens;
-    procedureUsed += tokens;
-    includedIds.add(item.entity.id);
-  }
-  for (const item of scored) {
-    if (includedIds.has(item.entity.id))
-      continue;
-    if (item.entity.type === "procedure")
-      continue;
-    if (item.score < MIN_RELEVANCE_THRESHOLD) {
-      manifest.excluded.push({
-        entityId: item.entity.id,
-        title: item.entity.title,
-        type: item.entity.type,
-        tier: item.entity.memory_tier,
-        relevanceScore: item.score,
-        reason: "below_relevance_threshold"
-      });
-      continue;
-    }
-    const tier = item.entity.memory_tier;
-    const { text, truncated } = truncateContent(item.entity.content, MAX_TOKENS_PER_ENTITY);
-    const tokens = estimateTokens(`### ${item.entity.title}
-${text}`);
-    if (tierUsed[tier] + tokens > tierBudgets[tier]) {
-      const totalRemaining = tokenBudget - totalUsed;
-      if (tokens > totalRemaining) {
-        manifest.excluded.push({
-          entityId: item.entity.id,
-          title: item.entity.title,
-          type: item.entity.type,
-          tier,
-          relevanceScore: item.score,
-          reason: "budget_exceeded"
-        });
-        continue;
-      }
-    }
-    if (totalUsed + tokens > tokenBudget) {
-      manifest.excluded.push({
-        entityId: item.entity.id,
-        title: item.entity.title,
-        type: item.entity.type,
-        tier,
-        relevanceScore: item.score,
-        reason: "total_budget_exceeded"
-      });
-      continue;
-    }
-    included.push({ ...item, tokens, truncated });
-    item.entity.content = text;
-    totalUsed += tokens;
-    tierUsed[tier] += tokens;
-    includedIds.add(item.entity.id);
-  }
-  manifest.budgetUsed = totalUsed;
-  const procedureItems = included.filter((i) => i.entity.type === "procedure");
-  manifest.tierBreakdown = {
-    reference: {
-      count: included.filter((i) => i.entity.memory_tier === "reference" && i.entity.type !== "procedure").length,
-      tokens: tierUsed.reference
-    },
-    episode: {
-      count: included.filter((i) => i.entity.memory_tier === "episode" && i.entity.type !== "procedure").length,
-      tokens: tierUsed.episode
-    },
-    draft: {
-      count: included.filter((i) => i.entity.memory_tier === "draft" && i.entity.type !== "procedure").length,
-      tokens: tierUsed.draft
-    }
-  };
-  manifest.procedureBreakdown = {
-    count: procedureItems.length,
-    tokens: procedureUsed,
-    budget: procedureBudget
-  };
-  for (const item of included) {
-    manifest.included.push({
-      entityId: item.entity.id,
-      title: item.entity.title,
-      type: item.entity.type,
-      tier: item.entity.memory_tier,
-      relevanceScore: item.score,
-      reasons: item.reasons,
-      tokenCount: item.tokens,
-      truncated: item.truncated
-    });
-  }
-  const contextSections = [];
-  const nonProcedureItems = included.filter((i) => i.entity.type !== "procedure");
-  if (included.length > 0) {
-    if (procedureItems.length > 0) {
-      contextSections.push(`## Procedures (${procedureItems.length} loaded, ${procedureUsed}/${procedureBudget} tokens)`);
-      for (const item of procedureItems) {
-        const tags = item.entity.tags.length > 0 ? ` [${item.entity.tags.join(", ")}]` : "";
-        const tierLabel = item.entity.memory_tier !== "reference" ? ` (${item.entity.memory_tier})` : "";
-        contextSections.push(`
-### ${item.entity.title} (confidence: ${item.entity.confidence})${tierLabel}${tags}`);
-        contextSections.push(item.entity.content);
-      }
-    }
-    if (nonProcedureItems.length > 0) {
-      contextSections.push(`
-## Relevant Memories (${nonProcedureItems.length} loaded, ${manifest.excluded.length} excluded)`);
-      contextSections.push(`*Assembly: ${assemblyId} | Budget: ${totalUsed}/${tokenBudget} tokens*`);
-      for (const item of nonProcedureItems) {
-        const tags = item.entity.tags.length > 0 ? ` [${item.entity.tags.join(", ")}]` : "";
-        const tierLabel = item.entity.memory_tier !== "reference" ? ` (${item.entity.memory_tier})` : "";
-        contextSections.push(`
-### ${item.entity.title} (${item.entity.type}, confidence: ${item.entity.confidence})${tierLabel}${tags}`);
-        contextSections.push(item.entity.content);
-      }
-    }
-  }
-  incrementAccessCounts(client2, included.map((i) => i.entity.id)).catch(() => {});
-  promoteEligibleEntities(client2, included.map((i) => i.entity)).catch(() => {});
-  return {
-    context: contextSections.join(`
-`),
-    manifest,
-    memories: included.map((i) => i.entity)
-  };
-}
-function mapToContextEntity(raw) {
-  const e = raw;
-  return {
-    id: e.id,
-    type: e.type,
-    title: e.title,
-    content: e.content,
-    confidence: e.confidence ?? 1,
-    tags: e.tags || [],
-    memory_tier: e.memory_tier || "reference",
-    access_count: e.access_count || 0,
-    last_accessed_at: e.last_accessed_at || null,
-    created_at: e.created_at || "",
-    updated_at: e.updated_at || "",
-    metadata: e.metadata ?? undefined,
-    rrf_score: e.rrf_score ?? undefined,
-    fts_rank: e.fts_rank ?? undefined,
-    semantic_rank: e.semantic_rank ?? undefined
-  };
-}
-async function incrementAccessCounts(client2, entityIds) {
-  if (entityIds.length === 0)
-    return;
-  try {
-    await client2.batchTouchMemoryEntities(entityIds);
-  } catch {
-    await Promise.allSettled(entityIds.map((id) => client2.touchMemoryEntity(id)));
-  }
-}
-async function promoteEligibleEntities(client2, entities) {
-  for (const entity of entities) {
-    if (entity.memory_tier === "reference")
-      continue;
-    if (!entity.created_at)
-      continue;
-    const promotion = checkPromotion(entity.memory_tier, entity.access_count + 1, entity.confidence, entity.created_at);
-    if (promotion.eligible && promotion.targetTier) {
-      try {
-        await client2.updateMemoryEntity(entity.id, {
-          memory_tier: promotion.targetTier,
-          metadata: {
-            ...entity.metadata || {},
-            promoted_at: new Date().toISOString(),
-            promotion_reason: promotion.reason,
-            promoted_from: entity.memory_tier
-          }
-        });
-      } catch {}
-    }
-  }
-}
-function cacheManifest(manifest) {
-  if (manifestCache.size >= MAX_CACHE_SIZE) {
-    const firstKey = manifestCache.keys().next().value;
-    if (firstKey)
-      manifestCache.delete(firstKey);
-  }
-  manifestCache.set(manifest.assemblyId, manifest);
-}
-function getCachedManifest(assemblyId) {
-  return manifestCache.get(assemblyId);
-}
-function trackSessionAssembly(cardId, assemblyId) {
-  if (sessionAssemblyMap.size >= MAX_SESSION_MAP_SIZE) {
-    const firstKey = sessionAssemblyMap.keys().next().value;
-    if (firstKey)
-      sessionAssemblyMap.delete(firstKey);
-  }
-  sessionAssemblyMap.set(cardId, assemblyId);
-}
-function getSessionAssemblyId(cardId) {
-  return sessionAssemblyMap.get(cardId);
-}
-async function recordContextFeedback(client2, cardId, sessionStatus, progressPercent, hadBlockers) {
-  const assemblyId = sessionAssemblyMap.get(cardId);
-  if (!assemblyId)
-    return { adjusted: 0 };
-  const manifest = manifestCache.get(assemblyId);
-  if (!manifest || manifest.included.length === 0)
-    return { adjusted: 0 };
-  let adjusted = 0;
-  const isSuccess = sessionStatus === "completed" && (progressPercent ?? 0) >= 100;
-  for (const entry of manifest.included) {
-    try {
-      if (isSuccess) {
-        const { entity } = await client2.getMemoryEntity(entry.entityId);
-        const e = entity;
-        const currentUsefulness = e.metadata?.usefulness_score ?? 0;
-        const newConfidence = Math.min((e.confidence ?? 0.5) + 0.05, 1);
-        await client2.updateMemoryEntity(entry.entityId, {
-          confidence: newConfidence,
-          metadata: {
-            usefulness_score: currentUsefulness + 1,
-            last_feedback_at: new Date().toISOString()
-          }
-        });
-        adjusted++;
-      } else if (hadBlockers) {
-        const { entity } = await client2.getMemoryEntity(entry.entityId);
-        const e = entity;
-        const newConfidence = Math.max((e.confidence ?? 0.5) - 0.02, 0.1);
-        await client2.updateMemoryEntity(entry.entityId, {
-          confidence: newConfidence,
-          metadata: {
-            last_feedback_at: new Date().toISOString()
-          }
-        });
-        adjusted++;
-      }
-    } catch {}
-  }
-  sessionAssemblyMap.delete(cardId);
-  return { adjusted };
-}
-var DEFAULT_TOKEN_BUDGET = 4000, MAX_TOKENS_PER_ENTITY = 500, MIN_RELEVANCE_THRESHOLD = 0.15, TIER_WEIGHTS, PROCEDURE_BUDGET_FRACTION = 0.15, TIER_BUDGET_ALLOCATION, MIN_REFERENCE_SLOTS = 1, GRAPH_WALK_MAX_DEPTH = 1, GRAPH_WALK_MAX_ENTITIES = 10, GRAPH_WALK_MIN_CONFIDENCE = 0.5, GRAPH_WALK_SEED_COUNT = 5, MAX_QUERY_VARIATIONS = 4, RERANK_CLUSTER_THRESHOLD = 0.05, RERANK_TOP_N = 10, RERANK_MIN_CANDIDATES = 5, RELATION_BONUSES, QUERY_SYNONYMS, manifestCache, MAX_CACHE_SIZE = 50, sessionAssemblyMap, MAX_SESSION_MAP_SIZE = 100;
-var init_context_assembly = __esm(() => {
-  init_dist();
-  TIER_WEIGHTS = {
-    reference: 1,
-    episode: 0.7,
-    draft: 0.4
-  };
-  TIER_BUDGET_ALLOCATION = {
-    reference: 0.6,
-    episode: 0.3,
-    draft: 0.1
-  };
-  RELATION_BONUSES = {
-    depends_on: 0.15,
-    resolved_by: 0.2,
-    relates_to: 0.1,
-    implements: 0.15,
-    blocks: 0.15,
-    references: 0.1,
-    extends: 0.1,
-    caused_by: 0.15
-  };
-  QUERY_SYNONYMS = {
-    auth: ["authentication", "authorization", "session"],
-    authentication: ["auth", "session", "sign-in"],
-    login: ["sign-in", "authentication", "session"],
-    bug: ["error", "issue", "defect", "problem"],
-    error: ["exception", "failure", "issue"],
-    fix: ["resolve", "patch", "repair", "correct"],
-    deploy: ["deployment", "release", "ship", "publish"],
-    test: ["testing", "spec", "assertion", "verify"],
-    config: ["configuration", "settings", "setup"],
-    db: ["database", "storage", "persistence"],
-    database: ["storage", "persistence", "data store"],
-    api: ["endpoint", "route", "service"],
-    ui: ["frontend", "component", "view"],
-    perf: ["performance", "speed", "latency"],
-    performance: ["speed", "latency", "optimization"]
-  };
-  manifestCache = new Map;
-  sessionAssemblyMap = new Map;
-});
-init_context_assembly();
-
-export {
-  trackSessionAssembly,
-  recordContextFeedback,
-  mapToContextEntity,
-  getSessionAssemblyId,
-  getCachedManifest,
-  expandQuery,
-  computeRelevanceScore,
-  cacheManifest,
-  assembleContext
-};