@gethmy/mcp 2.4.6 → 2.5.0

package/dist/lib/api-client.js

@@ -1,879 +1,35 @@
 var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
       enumerable: true,
       configurable: true,
-      set: (newValue) => all[name] = () => newValue
+      set: __exportSetter.bind(all, name)
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
-// ../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 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;
-}
-var PROMOTION_RULES;
-var init_lifecycle = __esm(() => {
-  PROMOTION_RULES = {
-    draftToEpisode: {
-      minAccessCount: 5,
-      minConfidence: 0.8,
-      minAgeDays: 1
-    },
-    episodeToReference: {
-      minAccessCount: 10,
-      minConfidence: 0.9,
-      minAgeDays: 7
-    }
-  };
-});
-// ../memory/dist/sync.js
-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;
-});
-
 // src/prompt-builder.ts
 var exports_prompt_builder = {};
 __export(exports_prompt_builder, {
+  proposePromptVariant: () => proposePromptVariant,
   inferCategoryFromLabels: () => inferCategoryFromLabels,
   getRoleFraming: () => getRoleFraming,
   getAvailableVariants: () => getAvailableVariants,
   getAvailableCategories: () => getAvailableCategories,
-  generatePrompt: () => generatePrompt
+  generatePrompt: () => generatePrompt,
+  computeContentHash: () => computeContentHash,
+  PROMPT_TEMPLATE_VERSION: () => PROMPT_TEMPLATE_VERSION
 });
+import { createHash, randomUUID } from "node:crypto";
+function computeContentHash(prompt) {
+  return createHash("sha256").update(prompt).digest("hex");
+}
 function inferCategoryFromLabels(labels) {
   for (const label of labels) {
     const normalizedName = label.name.toLowerCase().trim();
@@ -891,7 +47,7 @@ function inferCategoryFromLabels(labels) {
 function getRoleFraming(category) {
   return DEFAULT_ROLE_FRAMINGS[category];
 }
-function estimateTokens2(text) {
+function estimateTokens(text) {
   return Math.ceil(text.length / 4);
 }
 function formatSubtasks(subtasks) {
@@ -1054,8 +210,11 @@ ${customConstraints}`);
       linkedCardCount: links.length,
       memoryCount
     },
-    tokenEstimate: estimateTokens2(prompt),
-    ...assemblyId && { assemblyId }
+    tokenEstimate: estimateTokens(prompt),
+    ...assemblyId && { assemblyId },
+    promptId: randomUUID(),
+    contentHash: computeContentHash(prompt),
+    version: PROMPT_TEMPLATE_VERSION
   };
 }
 function extractSessionInsights(assembledContext) {
@@ -1137,7 +296,26 @@ function getAvailableCategories() {
 function getAvailableVariants() {
   return ["analysis", "draft", "execute"];
 }
-var LABEL_CATEGORY_MAP, DEFAULT_ROLE_FRAMINGS, VARIANT_INSTRUCTIONS;
+async function proposePromptVariant(contentHash, fetchCohort) {
+  if (!contentHash)
+    return null;
+  const cohort = await fetchCohort(contentHash);
+  if (!cohort || cohort.length < VARIANT_MIN_COHORT)
+    return null;
+  const completed = cohort.filter((r) => r.status === "completed" && (r.progressPercent ?? 0) >= 100 && !r.hadBlockers).length;
+  const completionRate = completed / cohort.length;
+  if (completionRate >= VARIANT_COMPLETION_THRESHOLD)
+    return null;
+  const blockerRate = cohort.filter((r) => r.hadBlockers).length / cohort.length;
+  const framingHint = blockerRate >= 0.4 ? "Cohort hits frequent blockers — try a more diagnostic framing (require root-cause + repro before any fix)." : "Cohort frequently stalls without finishing — try a more action-forcing framing (smaller subtasks, explicit DoD checklist).";
+  return {
+    contentHash,
+    cohortSize: cohort.length,
+    completionRate,
+    framingHint
+  };
+}
+var PROMPT_TEMPLATE_VERSION = 1, LABEL_CATEGORY_MAP, DEFAULT_ROLE_FRAMINGS, VARIANT_INSTRUCTIONS, VARIANT_MIN_COHORT = 10, VARIANT_COMPLETION_THRESHOLD = 0.4;
 var init_prompt_builder = __esm(() => {
   LABEL_CATEGORY_MAP = {
     bug: "bug",
@@ -1496,6 +674,26 @@ function getMemoryDir() {
   return join(homedir(), ".harmony", "memory");
 }
 
+// ../harmony-shared/dist/cardLinks.js
+var LINK_TYPE_INVERSES = {
+  relates_to: "relates_to",
+  blocks: "is_blocked_by",
+  duplicates: "is_duplicated_by",
+  is_part_of: "has_part"
+};
+function getDisplayLinkType(linkType, direction) {
+  if (direction === "outgoing")
+    return linkType;
+  return LINK_TYPE_INVERSES[linkType];
+}
+// ../harmony-shared/dist/constants.js
+var TIMINGS = {
+  SEARCH_DEBOUNCE: 300,
+  AUTOSAVE_DEBOUNCE: 1000,
+  TOAST_DURATION: 3000,
+  QUERY_STALE_TIME: 1000 * 60 * 5,
+  QUERY_GC_TIME: 1000 * 60 * 60 * 24
+};
 // src/api-client.ts
 var RETRY_CONFIG = {
   maxRetries: 3,
@@ -1592,6 +790,9 @@ class HarmonyApiClient {
   setApiKey(apiKey) {
     this.apiKey = apiKey;
   }
+  getApiKey() {
+    return this.apiKey;
+  }
   async request(method, path, body, options) {
     await requestSemaphore.acquire();
     try {
@@ -1841,22 +1042,6 @@ class HarmonyApiClient {
     const query = params.toString() ? `?${params.toString()}` : "";
     return this.request("GET", `/cards/${cardId}/agent-context${query}`);
   }
-  async getAgentProfile(workspaceId, agentIdentifier) {
-    const params = new URLSearchParams({
-      workspace_id: workspaceId,
-      agent_identifier: agentIdentifier
-    });
-    return this.request("GET", `/agent-profiles?${params.toString()}`);
-  }
-  async listAgentProfiles(workspaceId) {
-    const params = new URLSearchParams({ workspace_id: workspaceId });
-    return this.request("GET", `/agent-profiles?${params.toString()}`);
-  }
-  async refreshAgentProfiles(workspaceId) {
-    return this.request("POST", "/agent-profiles/refresh", {
-      workspace_id: workspaceId
-    });
-  }
   async createMemoryEntity(data) {
     return this.request("POST", "/memory/entities", data);
   }
@@ -1881,6 +1066,8 @@ class HarmonyApiClient {
       params.set("limit", String(options.limit));
     if (options.offset !== undefined)
       params.set("offset", String(options.offset));
+    if (options.include_superseded)
+      params.set("include_superseded", "true");
     return this.request("GET", `/memory/entities?${params.toString()}`);
   }
   async getMemoryEntity(entityId) {
@@ -2046,10 +1233,35 @@ class HarmonyApiClient {
   async generateApiKey(name) {
     return this.request("POST", "/api-keys", { name });
   }
+  async recordPromptHistory(data) {
+    return this.request("POST", "/prompt-history", data);
+  }
+  async recordPromptHistoryFeedback(sessionId, outcome) {
+    return this.request("POST", "/prompt-history/feedback", {
+      sessionId,
+      outcome
+    });
+  }
+  async getPromptHistoryCohort(contentHash) {
+    const params = new URLSearchParams({ content_hash: contentHash });
+    return this.request("GET", `/prompt-history/cohort?${params.toString()}`);
+  }
   async generateCardPrompt(options) {
-    const { assembleContext: assembleContext2, cacheManifest: cacheManifest2, generatePrompt: generatePrompt2 } = await loadPromptModules();
+    const { generatePrompt: generatePrompt2 } = await loadPromptModules();
     const cardResult = await this.getCard(options.cardId);
     const cardData = cardResult.card;
+    try {
+      const linksResult = await this.getCardLinks(options.cardId);
+      const rawLinks = linksResult.links || [];
+      cardData.links = rawLinks.filter((l) => l.target_card).map((l) => ({
+        target_card: l.target_card,
+        direction: l.direction,
+        display_type: getDisplayLinkType(l.link_type, l.direction)
+      }));
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.debug(`[generateCardPrompt] getCardLinks failed: ${msg}`);
+    }
     let columnData = null;
     const projectIdForBoard = options.projectId || cardData.project_id;
     if (projectIdForBoard) {
@@ -2062,51 +1274,29 @@ class HarmonyApiClient {
       } catch {}
     }
     const variant = options.variant || "execute";
-    let assembledContextStr;
-    let assemblyId;
+    const assembledContextStr = undefined;
+    const assemblyId = undefined;
     let memories;
     try {
       if (options.workspaceId && cardData.title) {
-        const cardLabels = (cardData.labels || []).map((l) => l.name);
-        const taskContext = [cardData.title, cardData.description || ""].filter(Boolean).join(" ");
-        const assembled = await assembleContext2({
-          workspaceId: options.workspaceId,
-          projectId: options.projectId,
-          taskContext,
-          cardLabels,
-          cardId: cardData.id,
-          client: this
+        const memoryResult = await this.searchMemoryEntities(options.workspaceId, cardData.title, {
+          project_id: options.projectId,
+          limit: 5
         });
-        if (assembled.context) {
-          assembledContextStr = assembled.context;
-          assemblyId = assembled.manifest.assemblyId;
-          cacheManifest2(assembled.manifest);
+        if (memoryResult.entities?.length > 0) {
+          memories = memoryResult.entities.map((e) => ({
+            id: e.id,
+            type: e.type,
+            title: e.title,
+            content: e.content,
+            confidence: e.confidence,
+            tags: e.tags || []
+          }));
         }
       }
     } catch (err) {
       const msg = err instanceof Error ? err.message : String(err);
-      console.debug(`[generateCardPrompt] Context assembly failed: ${msg}`);
-      try {
-        if (options.workspaceId && cardData.title) {
-          const memoryResult = await this.searchMemoryEntities(options.workspaceId, cardData.title, {
-            project_id: options.projectId,
-            limit: 5
-          });
-          if (memoryResult.entities?.length > 0) {
-            memories = memoryResult.entities.map((e) => ({
-              id: e.id,
-              type: e.type,
-              title: e.title,
-              content: e.content,
-              confidence: e.confidence,
-              tags: e.tags || []
-            }));
-          }
-        }
-      } catch (fallbackErr) {
-        const fallbackMsg = fallbackErr instanceof Error ? fallbackErr.message : String(fallbackErr);
-        console.debug(`[generateCardPrompt] Memory fallback also failed: ${fallbackMsg}`);
-      }
+      console.debug(`[generateCardPrompt] Memory search failed: ${msg}`);
     }
     const result = generatePrompt2({
       card: cardData,
@@ -2118,6 +1308,25 @@ class HarmonyApiClient {
       assembledContext: assembledContextStr,
       assemblyId
     });
+    try {
+      await this.recordPromptHistory({
+        cardId: cardData.id,
+        generatedPrompt: result.prompt,
+        variant,
+        contextIncluded: {
+          assemblyId: result.assemblyId ?? null,
+          tokenEstimate: result.tokenEstimate,
+          contextSummary: result.contextSummary
+        },
+        sessionId: options.sessionId ?? null,
+        contentHash: result.contentHash,
+        templateVersion: result.version,
+        confidence: 0.5
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.debug(`[generateCardPrompt] prompt_history persistence failed: ${msg}`);
+    }
     return {
       ...result,
       cardId: cardData.id,
@@ -2129,27 +1338,22 @@ class HarmonyApiClient {
 var _promptModules = null;
 async function loadPromptModules() {
   if (!_promptModules) {
-    const [ca, pb] = await Promise.all([
-      Promise.resolve().then(() => (init_context_assembly(), exports_context_assembly)),
-      Promise.resolve().then(() => (init_prompt_builder(), exports_prompt_builder))
-    ]);
+    const pb = await Promise.resolve().then(() => (init_prompt_builder(), exports_prompt_builder));
     _promptModules = {
-      assembleContext: ca.assembleContext,
-      cacheManifest: ca.cacheManifest,
       generatePrompt: pb.generatePrompt
     };
   }
   return _promptModules;
 }
-var client2 = null;
+var client = null;
 function getClient() {
-  if (!client2) {
-    client2 = new HarmonyApiClient;
+  if (!client) {
+    client = new HarmonyApiClient;
   }
-  return client2;
+  return client;
 }
 function resetClient() {
-  client2 = null;
+  client = null;
 }
 export {
   signupUser,