claude-memory-layer 1.0.45 → 1.0.47

package/dist/services/memory-service.js

@@ -2562,6 +2562,7 @@ var VectorOutbox = class {
 // src/core/retrieval-debug-lanes.ts
 var RETRIEVAL_DEBUG_LANE_NAMES = [
   "raw_event",
+  "session_event",
   "session_summary",
   "graph_path",
   "facet_match"
@@ -8421,6 +8422,18 @@ var COMMAND_ARTIFACT_PATTERNS = [
   /<local-command-stdout>[\s\S]*?<\/local-command-stdout>/i,
   /<local-command-stderr>[\s\S]*?<\/local-command-stderr>/i
 ];
+var LOW_SIGNAL_CONTEXT_PATTERNS = [
+  /<environment_context\b[\s\S]*<\/environment_context>/i,
+  /<turn_aborted>/i,
+  /^#\s*AGENTS\.md\s+instructions\b[\s\S]*<INSTRUCTIONS>/i,
+  /^\s*(?:understood[,\s.]*)?(?:stopping|stopped|pausing|paused)\s+here\b[\s\S]{0,180}\blet\s+me\s+know\s+when\s+you(?:'d|\s+would)?\s+like\s+to\s+continue\b/i,
+  /^\s*\[?CONTEXT\s+COMPACTION\s*[—-]\s*REFERENCE\s+ONLY\]?\b[\s\S]{0,600}\b(?:earlier\s+turns\s+were\s+compacted|handoff\s+from\s+a\s+previous\s+context\s+window|active\s+task)\b/i,
+  /^\s*Summary\s+generation\s+was\s+unavailable\.\s*\d+\s+message\(s\)\s+were\s+removed\s+to\s+free\s+context\s+space\b/i,
+  /^\s*---\s*END\s+OF\s+CONTEXT\s+SUMMARY\b/i,
+  /^\s*\[Your\s+active\s+task\s+list\s+was\s+preserved\s+across\s+context\s+compression\]/i,
+  /^➜\s+\S+\s+git:\([^)]*\)\s+/i,
+  /^\$\s+\S+/i
+];
 var CONTINUATION_QUERY_PATTERNS = [
   /^\s*(?:continue|resume|next|what(?:'s| is)? next|next\s+(?:step|task|action)|recommended\s+(?:next\s+)?(?:step|task|action)|what should (?:we|i) do next)\??\s*$/i,
   /^\s*(?:응\s*)?(?:이어서(?:\s*진행(?:해줘)?)?|계속(?:\s*해줘)?|다음\s*(?:단계|작업|추천\s*작업|추천|할\s*일)?(?:은|는)?(?:\s*(?:뭐야|진행(?:해줘)?))?\??|남은\s*(?:추가(?:로)?\s*)?(?:(?:할\s*만한\s*)?(?:작업|일)|할\s*일)?(?:은|는)?\s*(?:있어|있나|있나요|뭐야)\??|추천\s*작업(?:은|는)?(?:\s*뭐야)?\??|진행해줘)\s*$/i
@@ -8432,7 +8445,7 @@ var SHORT_REPAIR_FOLLOW_UP_PATTERNS = [
 var CURRENT_STATE_QUERY_PATTERNS = [
   /\bcurrent\b.*\b(?:state|status|deployment|blocker|pr|pull request)\b/i,
   /\b(?:still|as current|current)\b.*\b(?:unresolved|open|pending|not completed)\b/i,
-  /\b(?:old|obsolete|stale|resolved|already resolved)\b.*\b(?:current|still|unresolved|open|state|status)\b/i,
+  /\b(?:old|obsolete|stale|resolved|already resolved)\b.*\b(?:current|still|unresolved|open|status)\b/i,
   /(?:현재|아직|이전|오래된|해결된).*(?:상태|미해결|열린|블로커|PR|풀리퀘스트)/i
 ];
 var STALE_CONTENT_PATTERNS = [
@@ -8578,6 +8591,21 @@ function isCommandArtifactQuery(query) {
   if (normalized.includes("command-name") || normalized.includes("command-message")) return true;
   return COMMAND_ARTIFACT_PATTERNS.some((pattern) => pattern.test(trimmed));
 }
+function isCommandArtifactContent(content) {
+  const trimmed = content.trim();
+  if (!trimmed) return false;
+  const normalized = trimmed.toLowerCase();
+  if (normalized.includes("local-command-stdout") || normalized.includes("local-command-stderr")) return true;
+  if (normalized.includes("command-name") || normalized.includes("command-message")) return true;
+  return COMMAND_ARTIFACT_PATTERNS.some((pattern) => pattern.test(trimmed));
+}
+function isLowSignalContextContent(content) {
+  const trimmed = content.trim();
+  if (!trimmed) return true;
+  if (isCommandArtifactContent(trimmed)) return true;
+  if (LOW_SIGNAL_CONTEXT_PATTERNS.some((pattern) => pattern.test(trimmed))) return true;
+  return false;
+}
 function isGenericContinuationQuery(query) {
   const trimmed = query.trim();
   if (!trimmed) return false;
@@ -8595,6 +8623,16 @@ function isShortRepairFollowUpQuery(query) {
   if (tokens.length > 8) return false;
   return SHORT_REPAIR_FOLLOW_UP_PATTERNS.some((pattern) => pattern.test(trimmed));
 }
+function isLowConfidenceContextFallbackQuery(query) {
+  const trimmed = query.trim();
+  if (!trimmed) return false;
+  if (isGenericContinuationQuery(trimmed) || isShortRepairFollowUpQuery(trimmed)) return true;
+  const terms = new Set(tokenizeQualityText(trimmed));
+  if ((terms.has("compacted") || terms.has("compaction")) && terms.has("handoff")) return false;
+  const hasContinuationRecall = /^(?:continue|resume)\b/i.test(trimmed) && (terms.has("work") || terms.has("step") || terms.has("task") || terms.has("last") || terms.has("completed"));
+  const hasValidationGateRecall = terms.has("validation") && (terms.has("gate") || terms.has("check")) && (terms.has("run") || terms.has("before") || terms.has("commit") || terms.has("committing") || terms.has("change"));
+  return hasContinuationRecall || hasValidationGateRecall;
+}
 function isCurrentStateQuery(query) {
   const trimmed = query.trim();
   if (!trimmed) return false;
@@ -8768,6 +8806,7 @@ var Retriever = class {
   }
   async retrieve(query, options = {}) {
     const opts = { ...DEFAULT_OPTIONS, ...options };
+    const retrievalMode = options.retrievalMode ?? ((options.strategy ?? DEFAULT_OPTIONS.strategy) === "auto" ? "session-event-hybrid" : "event");
     const sessionFilter = opts.scope?.sessionId ?? opts.sessionId;
     const fallbackTrace = [];
     const qualityQuery = buildRetrievalQualityQuery(query);
@@ -8798,6 +8837,7 @@ var Retriever = class {
       decayPolicy: opts.decayPolicy,
       intentRewrite: opts.intentRewrite === true,
       graphHop: opts.graphHop,
+      retrievalMode,
       projectScopeMode: opts.projectScopeMode,
       projectHash: opts.projectHash,
       allowedProjectHashes: opts.allowedProjectHashes,
@@ -8816,6 +8856,7 @@ var Retriever = class {
         rerankWeights: opts.rerankWeights,
         decayPolicy: opts.decayPolicy,
         graphHop: opts.graphHop,
+        retrievalMode,
         projectScopeMode: opts.projectScopeMode,
         projectHash: opts.projectHash,
         allowedProjectHashes: opts.allowedProjectHashes,
@@ -8835,6 +8876,7 @@ var Retriever = class {
         rerankWeights: opts.rerankWeights,
         decayPolicy: opts.decayPolicy,
         graphHop: opts.graphHop,
+        retrievalMode,
         projectScopeMode: opts.projectScopeMode,
         projectHash: opts.projectHash,
         allowedProjectHashes: opts.allowedProjectHashes,
@@ -8855,14 +8897,37 @@ var Retriever = class {
         query,
         minScore: opts.minScore
       });
+      const expandedSummary = retrievalMode === "session-event-hybrid" ? await this.expandSessionEventHybrid(filteredSummary, {
+        query: qualityQuery,
+        currentStateQuery: query,
+        limit: opts.topK * 4
+      }) : filteredSummary;
+      const scopedExpandedSummary = retrievalMode === "session-event-hybrid" ? await this.applyScopeFilters(expandedSummary, {
+        scope: opts.scope,
+        projectScopeMode: opts.projectScopeMode,
+        projectHash: opts.projectHash,
+        allowedProjectHashes: opts.allowedProjectHashes,
+        facets: opts.facets
+      }) : expandedSummary;
+      const finalSummary = retrievalMode === "session-event-hybrid" ? this.applyQualityFilters(scopedExpandedSummary, {
+        query,
+        minScore: opts.minScore
+      }) : scopedExpandedSummary;
       current = {
-        results: filteredSummary,
-        candidateResults: filteredSummary,
-        matchResult: this.matcher.matchSearchResults(filteredSummary, () => 0)
+        results: finalSummary,
+        candidateResults: finalSummary,
+        matchResult: this.matcher.matchSearchResults(finalSummary, () => 0)
       };
       fallbackTrace.push("fallback:summary");
     }
-    const memories = await this.enrichResults(current.results.slice(0, opts.topK), opts);
+    const selectedResults = current.results.slice(0, opts.topK).filter((result) => {
+      if (current.matchResult.confidence !== "none") return true;
+      if (isLowConfidenceContextFallbackQuery(query)) {
+        return (result.semanticScore ?? result.score) >= 0.5 || result.score >= 0.5;
+      }
+      return (result.semanticScore ?? result.score) >= 0.62 || result.score >= 0.62;
+    });
+    const memories = await this.enrichResults(selectedResults, opts, query);
     const context = this.buildContext(memories, opts.maxTokens);
     return {
       memories,
@@ -8870,7 +8935,7 @@ var Retriever = class {
       totalTokens: this.estimateTokens(context),
       context,
       fallbackTrace,
-      selectedDebug: current.results.slice(0, opts.topK).map((r) => this.debugDetailForResult(r)),
+      selectedDebug: selectedResults.map((r) => this.debugDetailForResult(r)),
       candidateDebug: (current.candidateResults || []).slice(0, Math.max(opts.topK * 3, 20)).map((r) => this.debugDetailForResult(r)),
       rawQueryText: current.queryRewriteKind ? query : void 0,
       effectiveQueryText: current.effectiveQueryText,
@@ -8937,13 +9002,18 @@ var Retriever = class {
         initialResults = this.mergeResults(initialResults, rewrittenResults, input.topK * 3);
       }
     }
-    const expandedResults = input.graphHop?.enabled === false ? initialResults : await this.expandGraphHops(initialResults, {
+    const graphExpandedResults = input.graphHop?.enabled === false ? initialResults : await this.expandGraphHops(initialResults, {
       query,
       queryGraphEnabled: this.queryGraphExpansionEnabled,
       maxHops: clampGraphHops(input.graphHop?.maxHops ?? 1),
       hopPenalty: Math.max(0, input.graphHop?.hopPenalty ?? 0.08),
       limit: input.topK * 4
     });
+    const expandedResults = input.retrievalMode === "session-event-hybrid" ? await this.expandSessionEventHybrid(graphExpandedResults, {
+      query: rerankQuery,
+      currentStateQuery: query,
+      limit: input.topK * 4
+    }) : graphExpandedResults;
     const rerankedResults = input.rerankWithKeyword ? this.rerankByKeywordOverlap(expandedResults, rerankQuery, input.rerankWeights, input.decayPolicy) : expandedResults;
     const filtered = await this.applyScopeFilters(rerankedResults, {
       scope: input.scope,
@@ -8965,6 +9035,7 @@ var Retriever = class {
     if (isCurrentStateQuery(options.query)) {
       filtered = filtered.filter((result) => !isStaleOrSupersededContent(result.content));
     }
+    filtered = filtered.filter((result) => !isLowSignalContextContent(result.content));
     filtered = filtered.filter(
       (result) => this.isGraphPathResult(result) || hasDiscriminativeTermOverlap(options.query, result.content)
     );
@@ -8990,6 +9061,47 @@ var Retriever = class {
     }
     return [...byId.values()].sort((a, b) => b.score - a.score).slice(0, limit);
   }
+  async expandSessionEventHybrid(seeds, opts) {
+    if (seeds.length === 0 || opts.limit <= seeds.length) return seeds;
+    const queryTokens = this.tokenize(opts.query);
+    if (queryTokens.length === 0) return seeds;
+    const byId = /* @__PURE__ */ new Map();
+    for (const seed of seeds) byId.set(seed.eventId, seed);
+    const bestSeedBySession = /* @__PURE__ */ new Map();
+    for (const seed of [...seeds].sort((a, b) => b.score - a.score || compareStable(a.eventId, b.eventId))) {
+      if (!seed.sessionId || bestSeedBySession.has(seed.sessionId)) continue;
+      bestSeedBySession.set(seed.sessionId, seed);
+    }
+    const suppressStaleState = isCurrentStateQuery(opts.currentStateQuery);
+    for (const [sessionId, seed] of bestSeedBySession) {
+      const sessionEvents = await this.eventStore.getSessionEvents(sessionId);
+      for (const event of [...sessionEvents].sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime())) {
+        if (byId.has(event.id)) continue;
+        if (isLowSignalContextContent(event.content)) continue;
+        if (suppressStaleState && isStaleOrSupersededContent(event.content)) continue;
+        const lexicalScore = this.keywordOverlap(queryTokens, this.tokenize(event.content));
+        if (lexicalScore <= 0) continue;
+        if (shouldApplyTechnicalGuard(opts.query) && !hasTechnicalTermOverlap(opts.query, event.content)) continue;
+        const score = Math.min(0.95, Math.max(0.35, seed.score * 0.72 + lexicalScore * 0.28));
+        const row = withRetrievalLane({
+          id: `session-event-${seed.eventId}-${event.id}`,
+          eventId: event.id,
+          content: event.content,
+          score,
+          sessionId: event.sessionId,
+          eventType: event.eventType,
+          timestamp: event.timestamp.toISOString(),
+          semanticScore: seed.semanticScore ?? seed.score,
+          lexicalScore,
+          recencyScore: seed.recencyScore
+        }, { lane: "session_event", reason: `same_session:${seed.eventId}`, score });
+        byId.set(row.eventId, row);
+        if (byId.size >= opts.limit) break;
+      }
+      if (byId.size >= opts.limit) break;
+    }
+    return [...byId.values()].sort((a, b) => b.score - a.score || compareStable(a.eventId, b.eventId)).slice(0, opts.limit);
+  }
   async expandGraphHops(seeds, opts) {
     const byId = /* @__PURE__ */ new Map();
     for (const s of seeds) byId.set(s.eventId, s);
@@ -9305,7 +9417,7 @@ var Retriever = class {
   async retrieveRecent(limit = 100) {
     return this.eventStore.getRecentEvents(limit);
   }
-  async enrichResults(results, options) {
+  async enrichResults(results, options, query) {
     const memories = [];
     for (const result of results) {
       const event = await this.eventStore.getEvent(result.eventId);
@@ -9315,13 +9427,13 @@ var Retriever = class {
       }
       let sessionContext;
       if (options.includeSessionContext) {
-        sessionContext = await this.getSessionContext(event.sessionId, event.id);
+        sessionContext = await this.getSessionContext(event.sessionId, event.id, query);
       }
       memories.push({ event, score: result.score, sessionContext });
     }
     return memories;
   }
-  async getSessionContext(sessionId, eventId) {
+  async getSessionContext(sessionId, eventId, query) {
     const sessionEvents = await this.eventStore.getSessionEvents(sessionId);
     const eventIndex = sessionEvents.findIndex((e) => e.id === eventId);
     if (eventIndex === -1) return void 0;
@@ -9329,7 +9441,9 @@ var Retriever = class {
     const end = Math.min(sessionEvents.length, eventIndex + 2);
     const contextEvents = sessionEvents.slice(start, end);
     if (contextEvents.length <= 1) return void 0;
-    return contextEvents.filter((e) => e.id !== eventId).map((e) => `[${e.eventType}]: ${e.content.slice(0, 200)}...`).join("\n");
+    const suppressStaleState = isCurrentStateQuery(query);
+    const contextLines = contextEvents.filter((e) => e.id !== eventId).filter((e) => !isLowSignalContextContent(e.content)).filter((e) => !(suppressStaleState && isStaleOrSupersededContent(e.content))).map((e) => `[${e.eventType}]: ${e.content.slice(0, 200)}...`);
+    return contextLines.length > 0 ? contextLines.join("\n") : void 0;
   }
   buildUnifiedContext(projectResult, sharedMemories) {
     let context = projectResult.context;