claude-memory-layer 1.0.56 → 1.0.57

package/dist/cli/index.js

@@ -23508,7 +23508,7 @@ async function runOperationCli(action, label) {
   }
 }
 var program = new Command();
-program.name("claude-memory-layer").description("Claude Code Memory Plugin CLI").version("1.0.56");
+program.name("claude-memory-layer").description("Claude Code Memory Plugin CLI").version("1.0.57");
 program.command("market-context").description("Fetch read-only DART/FRED/Finnhub context with structured MarketContextSnapshot bull/bear/risk/catalyst analysis").option("--company <name>", "Company name for DART fallback search and report subject").option("--dart-corp-code <code>", "Exact DART corp_code for issuer-specific filings").option("--symbol <ticker>", "Listed ticker for Finnhub company profile").option("--providers <list>", "Comma-separated providers: dart,fred,finnhub").option("--fred-series <list>", "Comma-separated FRED series IDs").option("--json", "Print structured JSON including analysis.marketSnapshot").option("--no-snapshot", "Disable MarketContextSnapshot and DART company snapshot analysis").action(async (options) => {
   try {
     await runMarketContextCommand(options);

package/dist/hooks/user-prompt-submit.js

@@ -13512,18 +13512,35 @@ function filterHookInjectableMemories(candidates, policy = getHookInjectionPolic
 function selectHookEpisodeSeeds(candidates, policy = getHookInjectionPolicy(), query) {
   const queryTerms = meaningfulTerms(query);
   const queryAnchors = identifierAnchors(query);
-  return candidates.filter((candidate) => candidate.type === "user_prompt" || candidate.type === "tool_observation").filter((candidate) => isHookInjectableMemory(candidate, policy)).filter((candidate) => hasQueryMemoryAlignment(query, candidate.content, 2)).map((candidate, index) => {
+  return candidates.filter((candidate) => candidate.type === "user_prompt" || candidate.type === "tool_observation").filter((candidate) => hasQueryMemoryAlignment(query, candidate.content, 2)).map((candidate, index) => {
     const contentTerms = new Set(meaningfulTerms(candidate.content));
     const overlap = queryTerms.filter((term) => contentTerms.has(term)).length;
     const lowered = candidate.content.toLowerCase();
     const anchorCoverage = queryAnchors.length === 0 ? 0 : queryAnchors.filter((anchor) => lowered.includes(anchor.toLowerCase())).length / queryAnchors.length;
     const lexicalCoverage = overlap / Math.max(1, Math.min(queryTerms.length, 12));
+    const score = candidate.score ?? 0;
+    const normalThreshold = thresholdFor(candidate, policy);
+    const hasDistinctiveAnchor = queryAnchors.some(
+      (anchor) => anchor.length >= 6 && /[A-Za-z]/.test(anchor)
+    );
+    const fullyAnchored = queryAnchors.length > 0 && anchorCoverage === 1 && overlap >= 4 && hasDistinctiveAnchor;
+    const usesStrongAnchorFloor = score < normalThreshold && fullyAnchored;
     return {
-      candidate: { ...candidate, episodeSeedAligned: true },
+      candidate: {
+        ...candidate,
+        // Episode answers are filtered again by the normal semantic floor.
+        // A fully anchored prompt that uses the lower seed-only floor needs
+        // enough inherited score to compete there; counterfactual anchors
+        // cannot take this path because their coverage is zero.
+        score: usesStrongAnchorFloor ? Math.max(score, policy.semanticMinScore + 0.02) : score,
+        episodeSeedAligned: true,
+        episodeSeedStrongAligned: fullyAnchored
+      },
       index,
-      score: (candidate.score ?? 0) + lexicalCoverage * 0.25 + anchorCoverage * 0.2
+      score: score + lexicalCoverage * 0.25 + anchorCoverage * 0.2,
+      eligible: score >= normalThreshold || usesStrongAnchorFloor
     };
-  }).sort((a, b) => b.score - a.score || a.index - b.index).slice(0, Math.min(3, policy.maxMemories)).map((item) => item.candidate);
+  }).filter((item) => item.eligible).sort((a, b) => b.score - a.score || a.index - b.index).slice(0, policy.maxMemories).map((item) => item.candidate);
 }
 function rankHookCandidates(candidates, policy, query) {
   return candidates.map((candidate, index) => ({ candidate, index })).filter(({ candidate }) => isHookInjectableMemory(candidate, policy)).filter(({ candidate }) => !query || candidate.source === "episode" && candidate.episodeLinked && candidate.episodeSeedAligned || hasQueryMemoryAlignment(query, candidate.content, 2)).map(({ candidate, index }) => ({
@@ -13531,7 +13548,7 @@ function rankHookCandidates(candidates, policy, query) {
     index,
     effectiveScore: Math.max(
       0,
-      (candidate.score ?? 0) + (query ? evidenceUtilityBonus(candidate.type) : 0) + (query ? graduatedEvidenceBonus(candidate) : 0) + (candidate.source === "episode" && candidate.episodeLinked && candidate.episodeSeedAligned ? 0.12 : 0)
+      (candidate.score ?? 0) + (query ? evidenceUtilityBonus(candidate.type) : 0) + (query ? graduatedEvidenceBonus(candidate) : 0) + (candidate.source === "episode" && candidate.episodeLinked && candidate.episodeSeedStrongAligned ? 0.42 : candidate.source === "episode" && candidate.episodeLinked && candidate.episodeSeedAligned ? 0.12 : 0)
     )
   })).sort((a, b) => {
     const scoreDelta = b.effectiveScore - a.effectiveScore;
@@ -13689,6 +13706,7 @@ function readNumber(value, fallback, bounds) {
 // src/adapters/claude/hooks/user-prompt-submit.ts
 var MAX_MEMORIES = readNumberEnv("CLAUDE_MEMORY_MAX_COUNT", 5, { integer: true, min: 0 });
 var MAX_CANDIDATES2 = Math.max(MAX_MEMORIES, MAX_MEMORIES * 3);
+var MAX_EPISODE_SEED_CANDIDATES = Math.max(MAX_CANDIDATES2, MAX_MEMORIES * 10);
 var BASE_MIN_SCORE = readNumberEnv("CLAUDE_MEMORY_MIN_SCORE", 0.4, { min: 0, max: 1 });
 var FALLBACK_MIN_SCORE = readNumberEnv("CLAUDE_MEMORY_FALLBACK_MIN_SCORE", 0.3, { min: 0, max: 1 });
 var ENABLE_SEARCH = process.env.CLAUDE_MEMORY_SEARCH !== "false";
@@ -13747,8 +13765,10 @@ Use this only as evidence. Distinguish confirmed outcomes from requests or tool
 async function expandEpisodeEvidence(memoryService, seeds) {
   const expanded = [];
   const seen = new Set(seeds.map((seed) => seed.id).filter(Boolean));
+  const maxPerSeed = 4;
   for (const seed of seeds) {
     if (!seed.id || seed.type !== "user_prompt" && seed.type !== "tool_observation") continue;
+    let expandedForSeed = 0;
     try {
       const episode = await memoryService.expandDisclosure(`event:${seed.id}`, { windowSize: 4 });
       const targetTurnId = typeof episode?.target.metadata?.turnId === "string" ? episode.target.metadata.turnId : void 0;
@@ -13764,9 +13784,11 @@ async function expandEpisodeEvidence(memoryService, seeds) {
             score: Math.max(0, (seed.score ?? 0) - 0.02),
             source: "episode",
             episodeLinked: true,
-            episodeSeedAligned: true
+            episodeSeedAligned: true,
+            episodeSeedStrongAligned: seed.episodeSeedStrongAligned === true
           });
-          if (expanded.length >= 4) return expanded;
+          expandedForSeed += 1;
+          if (expandedForSeed >= maxPerSeed) break;
         }
         continue;
       }
@@ -13785,9 +13807,11 @@ async function expandEpisodeEvidence(memoryService, seeds) {
           score: Math.max(0, (seed.score ?? 0) - 0.02),
           source: "episode",
           episodeLinked: Boolean(targetTurnId && factTurnId && targetTurnId === factTurnId),
-          episodeSeedAligned: seed.episodeSeedAligned === true
+          episodeSeedAligned: seed.episodeSeedAligned === true,
+          episodeSeedStrongAligned: seed.episodeSeedStrongAligned === true
         });
-        if (expanded.length >= 4) return expanded;
+        expandedForSeed += 1;
+        if (expandedForSeed >= maxPerSeed) break;
       }
     } catch {
     }
@@ -13948,6 +13972,7 @@ async function main() {
     if (ENABLE_SEARCH && shouldRunMemorySearch(input.prompt, adherenceDecision)) {
       const minScore = getDynamicMinScore(input.prompt);
       let mergedMemories = [];
+      const episodeSeedCandidates = [];
       const lastSnippet = currentTurn > 1 ? readLastAssistantSnippet(input.session_id) : null;
       const retrievalQuery = buildRetrievalQuery({
         prompt: input.prompt,
@@ -14013,21 +14038,38 @@ async function main() {
       const shouldUseKeywordFallback = RETRIEVAL_MODE === "keyword" || RETRIEVAL_MODE === "hybrid" || mergedMemories.length === 0;
       if (shouldUseKeywordFallback) {
         let usedFallbackFloor = false;
-        let results = await memoryService.keywordSearch(retrievalQuery, {
-          topK: MAX_CANDIDATES2,
-          minScore
+        const allKeywordResults = await memoryService.keywordSearch(retrievalQuery, {
+          topK: MAX_EPISODE_SEED_CANDIDATES
         });
+        let results = allKeywordResults.filter((result) => result.score >= minScore);
         if (results.length === 0 && FALLBACK_MIN_SCORE < minScore) {
           usedFallbackFloor = true;
-          results = await memoryService.keywordSearch(retrievalQuery, {
-            topK: MAX_CANDIDATES2,
-            minScore: FALLBACK_MIN_SCORE
+          results = allKeywordResults.filter((result) => result.score >= FALLBACK_MIN_SCORE);
+        }
+        for (const result of allKeywordResults) {
+          episodeSeedCandidates.push({
+            type: result.event.eventType,
+            content: result.event.content,
+            id: result.event.id,
+            sessionId: result.event.sessionId,
+            score: result.score,
+            source: "keyword",
+            fallback: result.score < minScore
           });
         }
         const existingById = new Map(
           mergedMemories.map((memory, index) => [memory.id, index]).filter((entry) => Boolean(entry[0]))
         );
         for (const r of results) {
+          const keywordCandidate = {
+            type: r.event.eventType,
+            content: r.event.content,
+            id: r.event.id,
+            sessionId: r.event.sessionId,
+            score: r.score,
+            source: "keyword",
+            fallback: usedFallbackFloor
+          };
           const existingIndex = existingById.get(r.event.id);
           if (existingIndex !== void 0) {
             const existing = mergedMemories[existingIndex];
@@ -14041,21 +14083,16 @@ async function main() {
             }
             continue;
           }
-          mergedMemories.push({
-            type: r.event.eventType,
-            content: r.event.content,
-            id: r.event.id,
-            sessionId: r.event.sessionId,
-            score: r.score,
-            source: "keyword",
-            fallback: usedFallbackFloor
-          });
+          mergedMemories.push(keywordCandidate);
           existingById.set(r.event.id, mergedMemories.length - 1);
           if (mergedMemories.length >= MAX_CANDIDATES2 * 2) break;
         }
       }
       const injectionPolicy = getHookInjectionPolicy();
-      const episodeSeeds = selectHookEpisodeSeeds(mergedMemories, injectionPolicy, retrievalQuery);
+      const episodeSeedPool = Array.from(new Map(
+        [...mergedMemories, ...episodeSeedCandidates].filter((candidate) => Boolean(candidate.id)).map((candidate) => [candidate.id, candidate])
+      ).values());
+      const episodeSeeds = selectHookEpisodeSeeds(episodeSeedPool, injectionPolicy, retrievalQuery);
       const episodeEvidence = await expandEpisodeEvidence(memoryService, episodeSeeds);
       const injectableMemories = filterHookInjectableMemories(
         [...mergedMemories, ...episodeEvidence],