claude-memory-layer 1.0.32 → 1.0.34

package/dist/mcp/index.js

@@ -10308,12 +10308,12 @@ var tools = [
         projectPath: projectPathProperty,
         refreshLatest: {
           type: "boolean",
-          description: "Explicit opt-in: import latest local session history before retrieval. Requires absolute projectPath and mutates project memory (default: false)."
+          description: "Import latest local session history before retrieval. Generic continuation queries auto-refresh when absolute projectPath is supplied and no sessionId filter is set; set false to opt out. Auto-refresh and explicit true both mutate project memory; explicit true also requires absolute projectPath."
         },
         refreshSources: {
           type: "array",
           items: { type: "string", enum: ["claude", "codex", "hermes"] },
-          description: "Sources to refresh when refreshLatest is true (default: hermes and codex)"
+          description: "Sources to refresh when refreshLatest is true or auto-refresh runs (default: hermes and codex)"
         },
         refreshSessionLimit: {
           type: "number",
@@ -12667,10 +12667,15 @@ function sqliteClose(db) {
 function toDateFromSQLite(value) {
   if (value instanceof Date)
     return value;
-  if (typeof value === "string")
-    return new Date(value);
   if (typeof value === "number")
     return new Date(value);
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (/^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}(?:\.\d+)?$/.test(trimmed)) {
+      return /* @__PURE__ */ new Date(trimmed.replace(" ", "T") + "Z");
+    }
+    return new Date(trimmed);
+  }
   return new Date(String(value));
 }
 function toSQLiteTimestamp(date) {
@@ -12736,6 +12741,13 @@ var MarkdownMirror2 = class {
 };
 
 // src/core/sqlite-event-store.ts
+function normalizeQueryRewriteKind(value) {
+  const normalized = (value || "").trim().toLowerCase();
+  if (normalized === "follow-up-context" || normalized === "intent-rewrite")
+    return normalized;
+  return "none";
+}
+var REWRITTEN_QUERY_REWRITE_KIND_SQL = `LOWER(TRIM(COALESCE(query_rewrite_kind, 'none'))) IN ('follow-up-context', 'intent-rewrite')`;
 var SQLiteEventStore = class {
   db;
   initialized = false;
@@ -12996,6 +13008,8 @@ var SQLiteEventStore = class {
         session_id TEXT,
         project_hash TEXT,
         query_text TEXT NOT NULL,
+        raw_query_text TEXT,
+        query_rewrite_kind TEXT,
         strategy TEXT,
         candidate_event_ids TEXT,
         selected_event_ids TEXT,
@@ -13037,6 +13051,8 @@ var SQLiteEventStore = class {
       CREATE INDEX IF NOT EXISTS idx_helpfulness_event ON memory_helpfulness(event_id);
       CREATE INDEX IF NOT EXISTS idx_helpfulness_session ON memory_helpfulness(session_id);
       CREATE INDEX IF NOT EXISTS idx_helpfulness_score ON memory_helpfulness(helpfulness_score DESC);
+      CREATE INDEX IF NOT EXISTS idx_helpfulness_created_at ON memory_helpfulness(created_at);
+      CREATE INDEX IF NOT EXISTS idx_helpfulness_measured_at ON memory_helpfulness(measured_at);
       CREATE INDEX IF NOT EXISTS idx_retrieval_traces_created_at ON retrieval_traces(created_at DESC);
       CREATE INDEX IF NOT EXISTS idx_retrieval_traces_project_hash ON retrieval_traces(project_hash);
       CREATE INDEX IF NOT EXISTS idx_retrieval_traces_session_id ON retrieval_traces(session_id);
@@ -13070,6 +13086,18 @@ var SQLiteEventStore = class {
       sqliteExec(this.db, `ALTER TABLE retrieval_traces ADD COLUMN candidate_details_json TEXT;`);
     } catch {
     }
+    try {
+      sqliteExec(this.db, `ALTER TABLE retrieval_traces ADD COLUMN raw_query_text TEXT;`);
+    } catch {
+    }
+    try {
+      sqliteExec(this.db, `ALTER TABLE retrieval_traces ADD COLUMN query_rewrite_kind TEXT;`);
+    } catch {
+    }
+    try {
+      sqliteExec(this.db, `CREATE INDEX IF NOT EXISTS idx_retrieval_traces_query_rewrite_kind ON retrieval_traces(query_rewrite_kind);`);
+    } catch {
+    }
     const tableInfo = sqliteAll(this.db, "PRAGMA table_info(events)", []);
     const columnNames = tableInfo.map((col) => col.name);
     if (!columnNames.includes("access_count")) {
@@ -13855,8 +13883,11 @@ var SQLiteEventStore = class {
   /**
    * Get helpfulness statistics for dashboard
    */
-  async getHelpfulnessStats() {
+  async getHelpfulnessStats(since) {
     await this.initialize();
+    const sinceIso = since?.toISOString();
+    const evaluatedWhere = sinceIso ? `WHERE measured_at IS NOT NULL AND datetime(created_at) >= datetime(?)` : `WHERE measured_at IS NOT NULL`;
+    const totalWhere = sinceIso ? `WHERE datetime(created_at) >= datetime(?)` : ``;
     const stats = sqliteGet(
       this.db,
       `SELECT
@@ -13866,11 +13897,13 @@ var SQLiteEventStore = class {
          SUM(CASE WHEN helpfulness_score >= 0.4 AND helpfulness_score < 0.7 THEN 1 ELSE 0 END) as neutral,
          SUM(CASE WHEN helpfulness_score < 0.4 THEN 1 ELSE 0 END) as unhelpful
        FROM memory_helpfulness
-       WHERE measured_at IS NOT NULL`
+       ${evaluatedWhere}`,
+      sinceIso ? [sinceIso] : []
     );
     const totalRow = sqliteGet(
       this.db,
-      `SELECT COUNT(*) as total FROM memory_helpfulness`
+      `SELECT COUNT(*) as total FROM memory_helpfulness ${totalWhere}`,
+      sinceIso ? [sinceIso] : []
     );
     return {
       avgScore: Math.round((stats?.avg_score || 0) * 100) / 100,
@@ -13969,18 +14002,21 @@ var SQLiteEventStore = class {
   async recordRetrievalTrace(input) {
     await this.initialize();
     const traceId = randomUUID5();
+    const queryRewriteKind = normalizeQueryRewriteKind(input.queryRewriteKind);
     sqliteRun(
       this.db,
       `INSERT INTO retrieval_traces (
-        trace_id, session_id, project_hash, query_text, strategy,
+        trace_id, session_id, project_hash, query_text, raw_query_text, query_rewrite_kind, strategy,
         candidate_event_ids, selected_event_ids, candidate_details_json, selected_details_json,
         candidate_count, selected_count, confidence, fallback_trace
-      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
       [
         traceId,
         input.sessionId || null,
         input.projectHash || null,
         input.queryText,
+        input.rawQueryText || null,
+        queryRewriteKind,
         input.strategy || null,
         JSON.stringify(input.candidateEventIds || []),
         JSON.stringify(input.selectedEventIds || []),
@@ -14006,6 +14042,8 @@ var SQLiteEventStore = class {
         sessionId: row.session_id || void 0,
         projectHash: row.project_hash || void 0,
         queryText: row.query_text,
+        rawQueryText: row.raw_query_text || void 0,
+        queryRewriteKind: normalizeQueryRewriteKind(row.query_rewrite_kind),
         strategy: row.strategy || void 0,
         candidateEventIds: row.candidate_event_ids ? JSON.parse(row.candidate_event_ids) : [],
         selectedEventIds: row.selected_event_ids ? JSON.parse(row.selected_event_ids) : [],
@@ -14032,6 +14070,11 @@ var SQLiteEventStore = class {
           COUNT(*) as total_queries,
           AVG(candidate_count) as avg_candidate_count,
           AVG(selected_count) as avg_selected_count,
+          SUM(CASE WHEN ${REWRITTEN_QUERY_REWRITE_KIND_SQL} THEN 1 ELSE 0 END) as rewritten_queries,
+          SUM(CASE WHEN ${REWRITTEN_QUERY_REWRITE_KIND_SQL} AND selected_count > 0 THEN 1 ELSE 0 END) as rewritten_queries_with_selection,
+          SUM(CASE WHEN NOT (${REWRITTEN_QUERY_REWRITE_KIND_SQL}) AND selected_count > 0 THEN 1 ELSE 0 END) as raw_queries_with_selection,
+          AVG(CASE WHEN ${REWRITTEN_QUERY_REWRITE_KIND_SQL} THEN selected_count END) as avg_selected_count_for_rewritten_queries,
+          AVG(CASE WHEN NOT (${REWRITTEN_QUERY_REWRITE_KIND_SQL}) THEN selected_count END) as avg_selected_count_for_raw_queries,
           CASE
             WHEN SUM(candidate_count) > 0 THEN (SUM(selected_count) * 1.0 / SUM(candidate_count))
             ELSE 0
@@ -14039,15 +14082,41 @@ var SQLiteEventStore = class {
          FROM retrieval_traces`,
         []
       );
+      const totalQueries = Number(row?.total_queries || 0);
+      const rewrittenQueries = Number(row?.rewritten_queries || 0);
+      const rawQueries = Math.max(0, totalQueries - rewrittenQueries);
+      const rewrittenQueriesWithSelection = Number(row?.rewritten_queries_with_selection || 0);
+      const rawQueriesWithSelection = Number(row?.raw_queries_with_selection || 0);
       return {
-        totalQueries: Number(row?.total_queries || 0),
+        totalQueries,
         avgCandidateCount: Number(row?.avg_candidate_count || 0),
         avgSelectedCount: Number(row?.avg_selected_count || 0),
-        selectionRate: Number(row?.selection_rate || 0)
+        selectionRate: Number(row?.selection_rate || 0),
+        rewrittenQueries,
+        rewriteRate: totalQueries > 0 ? rewrittenQueries / totalQueries : 0,
+        rewrittenQueriesWithSelection,
+        rawQueriesWithSelection,
+        rewrittenSelectionRate: rewrittenQueries > 0 ? rewrittenQueriesWithSelection / rewrittenQueries : 0,
+        rawSelectionRate: rawQueries > 0 ? rawQueriesWithSelection / rawQueries : 0,
+        avgSelectedCountForRewrittenQueries: Number(row?.avg_selected_count_for_rewritten_queries || 0),
+        avgSelectedCountForRawQueries: Number(row?.avg_selected_count_for_raw_queries || 0)
       };
     } catch (err) {
       if (err?.message?.includes("no such table")) {
-        return { totalQueries: 0, avgCandidateCount: 0, avgSelectedCount: 0, selectionRate: 0 };
+        return {
+          totalQueries: 0,
+          avgCandidateCount: 0,
+          avgSelectedCount: 0,
+          selectionRate: 0,
+          rewrittenQueries: 0,
+          rewriteRate: 0,
+          rewrittenQueriesWithSelection: 0,
+          rawQueriesWithSelection: 0,
+          rewrittenSelectionRate: 0,
+          rawSelectionRate: 0,
+          avgSelectedCountForRewrittenQueries: 0,
+          avgSelectedCountForRawQueries: 0
+        };
       }
       throw err;
     }
@@ -14869,8 +14938,55 @@ var LOW_SIGNAL_CONTEXT_PATTERNS = [
 ];
 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*$/i
+  /^\s*(?:응\s*)?(?:이어서(?:\s*진행(?:해줘)?)?|계속(?:\s*해줘)?|다음\s*(?:단계|작업|추천\s*작업|추천|할\s*일)?(?:은|는)?(?:\s*(?:뭐야|진행(?:해줘)?))?\??|남은\s*(?:추가(?:로)?\s*)?(?:(?:할\s*만한\s*)?(?:작업|일)|할\s*일)?(?:은|는)?\s*(?:있어|있나|있나요|뭐야)\??|추천\s*작업(?:은|는)?(?:\s*뭐야)?\??|진행해줘)\s*$/i
 ];
+var SHORT_REPAIR_FOLLOW_UP_PATTERNS = [
+  /^\s*(?:fix\s+(?:it|that)|repair\s+(?:it|that)|resolve\s+(?:it|that)|that\s+bug|same\s+issue)\s*$/i,
+  /^\s*(?:그거|그것|이거|이것)?\s*(?:고쳐줘|수정해줘|해결해줘|처리해줘)\s*$/i
+];
+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,
+  /(?:현재|아직|이전|오래된|해결된).*(?:상태|미해결|열린|블로커|PR|풀리퀘스트)/i
+];
+var STALE_CONTENT_PATTERNS = [
+  /\b(?:obsolete|superseded|outdated)\b/i,
+  /\bstale\s+(?:operational\s+)?state\b/i,
+  /\bstale\s+after\b/i,
+  /\bno\s+longer\s+(?:valid|current|applies?)\b/i,
+  /\bearlier\s+(?:pull request|pr)\b[\s\S]{0,160}\b(?:open|not completed|had not completed)\b/i,
+  /\bshould\s+not\s+be\s+injected\s+as\s+current\s+context\b/i,
+  /(?:오래된|더 이상 유효하지|현재 상태가 아님)/i
+];
+var CONTINUATION_EXPANSION = "current next step plan roadmap status validation replay rerank memory usefulness continuation";
+var REPAIR_FOLLOW_UP_EXPANSION = "review blocker fix pattern dashboard error state metrics bucket validation sanitize rerun unresolved";
+var RETRIEVAL_PRIVACY_DECISION_EXPANSION = "retrieval telemetry privacy public api dashboard dashboards rawQueryText queryText raw query text expose safe trace metadata trace id reason strategy rewrite kind aggregate count counts candidate selected public panel";
+var DECISION_RECALL_TERMS = /* @__PURE__ */ new Set([
+  "decide",
+  "decided",
+  "decision",
+  "agreed",
+  "policy",
+  "constraint"
+]);
+var RETRIEVAL_PRIVACY_SURFACE_TERMS = /* @__PURE__ */ new Set([
+  "retrieval",
+  "dashboard",
+  "telemetry",
+  "trace"
+]);
+var DECISION_TOPIC_WEAK_TERMS = /* @__PURE__ */ new Set([
+  "api",
+  "dashboard",
+  "retrieval",
+  "trace",
+  "telemetry",
+  "query",
+  "raw",
+  "count",
+  "counts"
+]);
 var GENERIC_TECHNICAL_TERMS = /* @__PURE__ */ new Set([
   "api",
   "cli",
@@ -14888,6 +15004,87 @@ var GENERIC_TECHNICAL_TERMS = /* @__PURE__ */ new Set([
   "db",
   "sql"
 ]);
+var LOW_INFORMATION_QUERY_TERMS = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "or",
+  "for",
+  "from",
+  "with",
+  "without",
+  "about",
+  "what",
+  "when",
+  "where",
+  "which",
+  "who",
+  "why",
+  "how",
+  "did",
+  "does",
+  "do",
+  "we",
+  "i",
+  "in",
+  "to",
+  "of",
+  "on",
+  "as",
+  "be",
+  "was",
+  "were",
+  "decide",
+  "decided",
+  "decision",
+  "agreed",
+  "policy",
+  "constraint",
+  "showing",
+  "can",
+  "you",
+  "me",
+  "show",
+  "tell",
+  "please",
+  "should",
+  "would",
+  "could",
+  "this",
+  "that",
+  "these",
+  "those",
+  "use",
+  "using",
+  "treat",
+  "continue",
+  "resume",
+  "next",
+  "step",
+  "task",
+  "action",
+  "current",
+  "state",
+  "status",
+  "old",
+  "already",
+  "still",
+  "near",
+  "today",
+  "\uC751",
+  "\uADF8\uAC70",
+  "\uADF8\uAC83",
+  "\uC774\uAC70",
+  "\uC774\uAC83",
+  "\uB2E4\uC74C",
+  "\uB2E8\uACC4",
+  "\uC9C4\uD589",
+  "\uC9C4\uD589\uD574\uC918",
+  "\uACC4\uC18D",
+  "\uC774\uC5B4\uC11C",
+  "\uACE0\uCCD0\uC918",
+  "\uC218\uC815\uD574\uC918",
+  "\uD574\uACB0\uD574\uC918"
+]);
 function isCommandArtifactQuery(query) {
   const trimmed = query.trim();
   if (!trimmed)
@@ -14933,6 +15130,60 @@ function isGenericContinuationQuery(query) {
     return false;
   return !/[A-Za-z0-9_-]+\.[A-Za-z0-9]+/.test(trimmed) && !/(?:^|\s)(?:feat|fix|chore|refactor|docs)\/[A-Za-z0-9._-]+/.test(trimmed) && !/[A-Za-z]:?[\\/]|\/Users\/|\.\/|\.\.\//.test(trimmed);
 }
+function isShortRepairFollowUpQuery(query) {
+  const trimmed = query.trim();
+  if (!trimmed)
+    return false;
+  if (extractTechnicalQueryTerms(trimmed).length > 0)
+    return false;
+  const tokens = trimmed.match(/[A-Za-z0-9가-힣#._/-]+/g) ?? [];
+  if (tokens.length > 8)
+    return false;
+  return SHORT_REPAIR_FOLLOW_UP_PATTERNS.some((pattern) => pattern.test(trimmed));
+}
+function isCurrentStateQuery(query) {
+  const trimmed = query.trim();
+  if (!trimmed)
+    return false;
+  return CURRENT_STATE_QUERY_PATTERNS.some((pattern) => pattern.test(trimmed));
+}
+function isStaleOrSupersededContent(content) {
+  const trimmed = content.trim();
+  if (!trimmed)
+    return false;
+  return STALE_CONTENT_PATTERNS.some((pattern) => pattern.test(trimmed));
+}
+function buildRetrievalQualityQuery(query) {
+  const trimmed = query.trim();
+  if (!trimmed)
+    return query;
+  if (isRetrievalPrivacyDecisionQuery(trimmed)) {
+    return `${trimmed} ${RETRIEVAL_PRIVACY_DECISION_EXPANSION}`;
+  }
+  if (isGenericContinuationQuery(trimmed)) {
+    return `${trimmed} ${CONTINUATION_EXPANSION}`;
+  }
+  if (isShortRepairFollowUpQuery(trimmed)) {
+    return `${trimmed} ${REPAIR_FOLLOW_UP_EXPANSION}`;
+  }
+  return query;
+}
+function isRetrievalPrivacyDecisionQuery(query) {
+  const trimmed = query.trim();
+  if (!trimmed)
+    return false;
+  const terms = new Set(tokenizeQualityText(trimmed));
+  const hasDecisionSignal = hasAnyTerm(terms, DECISION_RECALL_TERMS) || /(?:결정|정책|원칙)/i.test(trimmed);
+  if (!hasDecisionSignal)
+    return false;
+  const hasRawQuerySignal = terms.has("raw") && terms.has("query");
+  const hasPrivacySignal = terms.has("privacy") || terms.has("expose") || terms.has("redacted");
+  const hasRetrievalSurface = hasAnyTerm(terms, RETRIEVAL_PRIVACY_SURFACE_TERMS) || terms.has("api") && terms.has("query");
+  const hasQuerySurface = terms.has("query") && (terms.has("dashboard") || terms.has("trace") || terms.has("telemetry") || terms.has("api"));
+  const hasKoreanRetrievalSurface = /(?:검색|리트리벌|retrieval|대시보드|트레이스|텔레메트리|telemetry)/i.test(trimmed);
+  const hasKoreanPrivacySurface = /(?:원문|쿼리|프라이버시|개인정보|노출|트레이스|메타데이터)/i.test(trimmed);
+  return (hasRetrievalSurface || hasKoreanRetrievalSurface && hasKoreanPrivacySurface) && (hasRawQuerySignal || hasPrivacySignal || hasQuerySurface || hasKoreanPrivacySurface);
+}
 function extractTechnicalQueryTerms(query) {
   const matches = query.match(/[A-Za-z][A-Za-z0-9_.:-]{2,}/g) ?? [];
   const terms = matches.filter((term) => {
@@ -14950,9 +15201,87 @@ function hasTechnicalTermOverlap(query, content) {
   const normalizedContent = content.toLowerCase();
   return terms.some((term) => normalizedContent.includes(term));
 }
+function hasDiscriminativeTermOverlap(query, content) {
+  const queryTerms = extractDiscriminativeQueryTerms(query);
+  const contentTerms = new Set(tokenizeQualityText(content));
+  if (isRetrievalPrivacyDecisionQuery(query) && hasRetrievalPrivacyDecisionContent(contentTerms)) {
+    return true;
+  }
+  if (shouldRequireDecisionTopicOverlap(query)) {
+    const topicTerms = queryTerms.filter((term) => !DECISION_TOPIC_WEAK_TERMS.has(term));
+    if (topicTerms.length > 0) {
+      return topicTerms.some((term) => contentTerms.has(term));
+    }
+  }
+  if (queryTerms.length < 3)
+    return true;
+  const requiredHits = queryTerms.length >= 3 ? 2 : 1;
+  let hits = 0;
+  for (const term of queryTerms) {
+    if (contentTerms.has(term))
+      hits += 1;
+    if (hits >= requiredHits)
+      return true;
+  }
+  return false;
+}
 function shouldApplyTechnicalGuard(query) {
   return extractTechnicalQueryTerms(query).length > 0;
 }
+function hasAnyTerm(terms, expectedTerms) {
+  let found = false;
+  expectedTerms.forEach((term) => {
+    if (terms.has(term))
+      found = true;
+  });
+  return found;
+}
+function shouldRequireDecisionTopicOverlap(query) {
+  if (isRetrievalPrivacyDecisionQuery(query))
+    return false;
+  const trimmed = query.trim();
+  if (!trimmed)
+    return false;
+  const terms = new Set(tokenizeQualityText(trimmed));
+  return hasAnyTerm(terms, DECISION_RECALL_TERMS) || /(?:결정|정책|원칙)/i.test(trimmed);
+}
+function extractDiscriminativeQueryTerms(query) {
+  const seen = /* @__PURE__ */ new Set();
+  const terms = [];
+  for (const token of tokenizeQualityText(query)) {
+    if (LOW_INFORMATION_QUERY_TERMS.has(token))
+      continue;
+    if (GENERIC_TECHNICAL_TERMS.has(token))
+      continue;
+    if (seen.has(token))
+      continue;
+    seen.add(token);
+    terms.push(token);
+  }
+  return terms;
+}
+function hasRetrievalPrivacyDecisionContent(contentTerms) {
+  const hasDashboardTraceMetadata = contentTerms.has("dashboard") && (contentTerms.has("trace") || contentTerms.has("metadata")) && (contentTerms.has("safe") || contentTerms.has("strategy") || contentTerms.has("rewrite") || contentTerms.has("candidate") || contentTerms.has("selected") || contentTerms.has("count") || contentTerms.has("reason"));
+  const hasRawQueryPrivacyPolicy = contentTerms.has("retrieval") && (contentTerms.has("privacy") || contentTerms.has("expose") || contentTerms.has("raw") && contentTerms.has("query") && (contentTerms.has("dashboard") || contentTerms.has("telemetry") || contentTerms.has("api") || contentTerms.has("public")));
+  return hasDashboardTraceMetadata || hasRawQueryPrivacyPolicy;
+}
+function tokenizeQualityText(text) {
+  return text.replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase().replace(/[^A-Za-z0-9가-힣\s_.:-]/g, " ").split(/\s+/).flatMap((token) => token.split(/(?=[._:-])|(?<=[._:-])/g)).map((token) => normalizeQualityToken(token.replace(/^[._:-]+|[._:-]+$/g, ""))).filter((token) => token.length >= 2);
+}
+function normalizeQualityToken(token) {
+  if (token === "apis")
+    return "api";
+  if (token === "ids")
+    return "id";
+  if (LOW_INFORMATION_QUERY_TERMS.has(token) || GENERIC_TECHNICAL_TERMS.has(token))
+    return token;
+  if (token.length > 4 && token.endsWith("ies"))
+    return `${token.slice(0, -3)}y`;
+  if (token.length > 3 && token.endsWith("s") && !token.endsWith("ss") && !token.endsWith("us") && !token.endsWith("is")) {
+    return token.slice(0, -1);
+  }
+  return token;
+}
 
 // src/core/retriever.ts
 var DEFAULT_OPTIONS = {
@@ -15005,6 +15334,7 @@ var Retriever = class {
     const opts = { ...DEFAULT_OPTIONS, ...options };
     const sessionFilter = opts.scope?.sessionId ?? opts.sessionId;
     const fallbackTrace = [];
+    const qualityQuery = buildRetrievalQualityQuery(query);
     if (isCommandArtifactQuery(query)) {
       fallbackTrace.push("guard:command-artifact-query");
       const emptyMatch = this.matcher.matchSearchResults([], () => 0);
@@ -15021,6 +15351,7 @@ var Retriever = class {
     const fallbackEnabled = (opts.strategy ?? "auto") === "auto";
     const primaryStrategy = opts.strategy === "auto" ? "fast" : opts.strategy || "fast";
     let current = await this.runStage(query, {
+      qualityQuery,
       strategy: primaryStrategy,
       topK: opts.topK,
       minScore: opts.minScore,
@@ -15038,6 +15369,7 @@ var Retriever = class {
     fallbackTrace.push(`stage:primary:${primaryStrategy}`);
     if (fallbackEnabled && this.shouldFallback(current.matchResult, current.results) && primaryStrategy !== "deep") {
       current = await this.runStage(query, {
+        qualityQuery,
         strategy: "deep",
         topK: opts.topK,
         minScore: opts.minScore,
@@ -15055,6 +15387,7 @@ var Retriever = class {
     }
     if (fallbackEnabled && this.shouldFallback(current.matchResult, current.results)) {
       current = await this.runStage(query, {
+        qualityQuery,
         strategy: "deep",
         topK: opts.topK,
         minScore: Math.max(0.5, opts.minScore - 0.15),
@@ -15071,11 +15404,21 @@ var Retriever = class {
       fallbackTrace.push("fallback:scope-expanded");
     }
     if (fallbackEnabled && this.shouldFallback(current.matchResult, current.results)) {
-      const summary = await this.buildSummaryFallback(query, opts.topK);
+      const summary = await this.buildSummaryFallback(qualityQuery, opts.topK);
+      const scopedSummary = await this.applyScopeFilters(summary, {
+        scope: opts.scope,
+        projectScopeMode: opts.projectScopeMode,
+        projectHash: opts.projectHash,
+        allowedProjectHashes: opts.allowedProjectHashes
+      });
+      const filteredSummary = this.applyQualityFilters(scopedSummary, {
+        query,
+        minScore: opts.minScore
+      });
       current = {
-        results: summary,
-        candidateResults: summary,
-        matchResult: this.matcher.matchSearchResults(summary, () => 0)
+        results: filteredSummary,
+        candidateResults: filteredSummary,
+        matchResult: this.matcher.matchSearchResults(filteredSummary, () => 0)
       };
       fallbackTrace.push("fallback:summary");
     }
@@ -15100,7 +15443,10 @@ var Retriever = class {
         semanticScore: r.semanticScore,
         lexicalScore: r.lexicalScore,
         recencyScore: r.recencyScore
-      }))
+      })),
+      rawQueryText: current.queryRewriteKind ? query : void 0,
+      effectiveQueryText: current.effectiveQueryText,
+      queryRewriteKind: current.queryRewriteKind
     };
   }
   async retrieveUnified(query, options = {}) {
@@ -15138,8 +15484,11 @@ var Retriever = class {
     }
   }
   async runStage(query, input) {
-    let rerankQuery = query;
-    let initialResults = await this.searchByStrategy(query, {
+    const searchQuery = input.qualityQuery ?? query;
+    let rerankQuery = searchQuery;
+    let effectiveQueryText;
+    let queryRewriteKind;
+    let initialResults = await this.searchByStrategy(searchQuery, {
       strategy: input.strategy,
       topK: input.topK,
       minScore: input.minScore,
@@ -15147,9 +15496,12 @@ var Retriever = class {
     });
     if (input.intentRewrite && input.strategy === "deep" && this.queryRewriter) {
       const rewritten = (await this.queryRewriter(query))?.trim();
-      if (rewritten && rewritten !== query) {
-        rerankQuery = `${query} ${rewritten}`;
-        const rewrittenResults = await this.searchByStrategy(rewritten, {
+      const normalizedQuery = query.trim();
+      if (rewritten && rewritten !== normalizedQuery) {
+        effectiveQueryText = `${normalizedQuery} ${rewritten}`.trim();
+        queryRewriteKind = "intent-rewrite";
+        rerankQuery = buildRetrievalQualityQuery(effectiveQueryText);
+        const rewrittenResults = await this.searchByStrategy(buildRetrievalQualityQuery(rewritten), {
           strategy: "deep",
           topK: input.topK,
           minScore: Math.max(0.5, input.minScore - 0.1),
@@ -15176,10 +15528,14 @@ var Retriever = class {
     });
     const top = qualityFiltered.slice(0, input.topK);
     const matchResult = this.matcher.matchSearchResults(top, () => 0);
-    return { results: top, candidateResults: qualityFiltered, matchResult };
+    return { results: top, candidateResults: qualityFiltered, matchResult, effectiveQueryText, queryRewriteKind };
   }
   applyQualityFilters(results, options) {
     let filtered = [...results];
+    if (isCurrentStateQuery(options.query)) {
+      filtered = filtered.filter((result) => !isStaleOrSupersededContent(result.content));
+    }
+    filtered = filtered.filter((result) => hasDiscriminativeTermOverlap(options.query, result.content));
     if (shouldApplyTechnicalGuard(options.query)) {
       filtered = filtered.filter((result) => hasTechnicalTermOverlap(options.query, result.content));
     }
@@ -15487,7 +15843,21 @@ _Context:_ ${sessionContext}`;
     });
   }
   tokenize(text) {
-    return text.toLowerCase().replace(/[^\p{L}\p{N}\s]/gu, " ").split(/\s+/).filter((t) => t.length >= 2).slice(0, 64);
+    return text.replace(/([a-z])([A-Z])/g, "$1 $2").toLowerCase().replace(/[^\p{L}\p{N}\s]/gu, " ").split(/\s+/).map((token) => this.normalizeToken(token)).filter((t) => t.length >= 2).slice(0, 64);
+  }
+  normalizeToken(token) {
+    if (token === "apis")
+      return "api";
+    if (token === "ids")
+      return "id";
+    if (token === "does")
+      return token;
+    if (token.length > 4 && token.endsWith("ies"))
+      return `${token.slice(0, -3)}y`;
+    if (token.length > 3 && token.endsWith("s") && !token.endsWith("ss") && !token.endsWith("us") && !token.endsWith("is") && !token.endsWith("ps")) {
+      return token.slice(0, -1);
+    }
+    return token;
   }
   keywordOverlap(a, b) {
     if (a.length === 0 || b.length === 0)
@@ -15550,9 +15920,9 @@ var RetrievalAnalyticsService = class {
     await this.deps.initialize();
     return this.deps.retrievalStore.getHelpfulMemories(limit);
   }
-  async getHelpfulnessStats() {
+  async getHelpfulnessStats(since) {
     await this.deps.initialize();
-    return this.deps.retrievalStore.getHelpfulnessStats();
+    return this.deps.retrievalStore.getHelpfulnessStats(since);
   }
   /**
    * Extract topic keywords from event content (markdown headings and key terms).
@@ -15977,7 +16347,9 @@ var RetrievalOrchestrator = class {
     await this.deps.traceStore.recordRetrievalTrace({
       sessionId: options?.sessionId,
       projectHash: projectHash || void 0,
-      queryText: query,
+      queryText: result.effectiveQueryText || query,
+      rawQueryText: result.rawQueryText || (result.queryRewriteKind ? query : void 0),
+      queryRewriteKind: result.queryRewriteKind || "none",
       strategy: options?.strategy || "auto",
       candidateEventIds,
       selectedEventIds,
@@ -17992,8 +18364,8 @@ var MemoryService = class {
   /**
    * Get helpfulness statistics for dashboard
    */
-  async getHelpfulnessStats() {
-    return this.retrievalAnalyticsService.getHelpfulnessStats();
+  async getHelpfulnessStats(since) {
+    return this.retrievalAnalyticsService.getHelpfulnessStats(since);
   }
   /**
    * Mark a consolidated memory as accessed
@@ -19487,7 +19859,8 @@ var HermesSessionHistoryImporter = class {
           source: "hermes",
           hermesSource: session.source,
           sourceSessionId: session.id,
-          sourceSessionHash: hashLabel(session.id)
+          sourceSessionHash: hashLabel(session.id),
+          projectPath: effectiveProjectPath
         }
       );
       if (appendResult.success && appendResult.isDuplicate) {
@@ -19524,7 +19897,8 @@ var HermesSessionHistoryImporter = class {
             source: "hermes",
             hermesSource: session.source,
             sourceSessionId: session.id,
-            sourceSessionHash: hashLabel(session.id)
+            sourceSessionHash: hashLabel(session.id),
+            projectPath: effectiveProjectPath
           }
         );
         if (appendResult.success && appendResult.isDuplicate) {
@@ -20073,7 +20447,7 @@ async function handleToolCall(name, args) {
       case "mem-details":
         return await handleMemDetails(memoryService, args);
       case "mem-stats":
-        return await handleMemStats(memoryService);
+        return await handleMemStats(memoryService, args);
       case "mem-context-pack":
         return await handleMemContextPack(memoryService, args);
       case "mem-import-latest":
@@ -20109,19 +20483,19 @@ async function handleExternalMarketContext(args) {
 async function handleMemSearch(memoryService, args) {
   const query = args.query;
   const topK = Math.min(args.topK || 5, 20);
-  const result = await memoryService.retrieveMemories(query, {
-    topK,
-    sessionId: args.sessionId,
-    recordTrace: false
-  });
+  const sessionId = args.sessionId;
+  const search = await retrieveMcpMemories(memoryService, query, { topK, sessionId });
   const lines = [
     "## Memory Search Results",
     "",
-    `Found ${result.memories.length} relevant memories:`,
+    `Found ${search.memories.length} relevant memories:`,
     ""
   ];
-  for (let i = 0; i < result.memories.length; i++) {
-    const m = result.memories[i];
+  if (search.warning) {
+    lines.push(search.warning, "");
+  }
+  for (let i = 0; i < search.memories.length; i++) {
+    const m = search.memories[i];
     const citationId = generateCitationId(m.event.id);
     const date = m.event.timestamp.toISOString().split("T")[0];
     const preview = m.event.content.slice(0, 100) + (m.event.content.length > 100 ? "..." : "");
@@ -20136,6 +20510,52 @@ async function handleMemSearch(memoryService, args) {
     content: [{ type: "text", text: lines.join("\n") }]
   };
 }
+var SEMANTIC_VECTOR_FALLBACK_WARNING = "Warning: semantic/vector retrieval unavailable; used keyword fallback.";
+var SEMANTIC_VECTOR_FALLBACK_FAILED_WARNING = "Warning: semantic/vector retrieval unavailable; keyword fallback failed.";
+async function retrieveMcpMemories(memoryService, query, options) {
+  try {
+    const result = await memoryService.retrieveMemories(query, {
+      topK: options.topK,
+      sessionId: options.sessionId,
+      recordTrace: false
+    });
+    return { memories: result.memories };
+  } catch (error) {
+    if (!isVectorSchemaMismatchError(error)) {
+      throw error;
+    }
+    try {
+      const memories = options.sessionId ? rankSessionKeywordMatches(
+        query,
+        await memoryService.getSessionHistory(options.sessionId),
+        options.topK
+      ) : await memoryService.keywordSearch(query, { topK: options.topK });
+      return { memories, warning: SEMANTIC_VECTOR_FALLBACK_WARNING };
+    } catch {
+      return { memories: [], warning: SEMANTIC_VECTOR_FALLBACK_FAILED_WARNING };
+    }
+  }
+}
+function isVectorSchemaMismatchError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /no vector column/i.test(message) || /query vector dimension/i.test(message) || /vector[^\n]{0,80}dimension/i.test(message) || /dimension[^\n]{0,80}vector/i.test(message) || /lancedb[^\n]{0,120}schema/i.test(message);
+}
+function rankSessionKeywordMatches(query, events, topK) {
+  const queryTokens = tokenizeKeywordQuery(query);
+  if (queryTokens.length === 0)
+    return [];
+  return events.map((event) => ({ event, score: scoreKeywordMatch(event.content, queryTokens) })).filter((match) => match.score > 0).sort((a, b) => b.score - a.score || b.event.timestamp.getTime() - a.event.timestamp.getTime()).slice(0, topK);
+}
+function tokenizeKeywordQuery(value) {
+  return Array.from(new Set(
+    value.toLowerCase().split(/[^a-z0-9가-힣_]+/).map((token) => token.trim()).filter((token) => token.length > 1)
+  ));
+}
+function scoreKeywordMatch(content, queryTokens) {
+  const haystack = content.toLowerCase();
+  const hits = queryTokens.filter((token) => haystack.includes(token)).length;
+  return hits / queryTokens.length;
+}
 async function handleMemTimeline(memoryService, args) {
   const ids = args.ids;
   const windowSize = args.windowSize || 3;
@@ -20214,8 +20634,10 @@ async function handleMemContextPack(memoryService, args) {
   const sessionId = optionalString(args.sessionId);
   const projectPath = optionalString(args.projectPath);
   const genericContinuationQuery = isGenericContinuationQuery(query);
+  const explicitFreshnessRefresh = args.refreshLatest === true;
+  const autoFreshnessRefresh = args.refreshLatest !== false && !explicitFreshnessRefresh && genericContinuationQuery && sessionId === void 0 && projectPath !== void 0 && path14.isAbsolute(projectPath);
   const retrievalTopK = Math.min(topK * 3, 12);
-  const freshnessRun = args.refreshLatest === true ? await runLatestImport(memoryService, {
+  const freshnessRun = explicitFreshnessRefresh || autoFreshnessRefresh ? await runLatestImport(memoryService, {
     projectPath: projectPath || "",
     sources: sourceListArg(args.refreshSources),
     sessionLimit: numberArg(args.refreshSessionLimit, 1, 1, 10),
@@ -20225,10 +20647,8 @@ async function handleMemContextPack(memoryService, args) {
     sessionsDir: optionalString(args.sessionsDir),
     stateDb: optionalString(args.stateDb)
   }) : void 0;
-  const [searchResult, recentEvents] = await Promise.all([
-    memoryService.retrieveMemories(query, { topK: retrievalTopK, sessionId, recordTrace: false }),
-    memoryService.getRecentEvents(recentLimit)
-  ]);
+  const search = await retrieveMcpMemories(memoryService, query, { topK: retrievalTopK, sessionId });
+  const recentEvents = await memoryService.getRecentEvents(recentLimit);
   const timelineEvents = selectContextPackTimelineEvents(
     recentEvents,
     projectPath,
@@ -20236,7 +20656,7 @@ async function handleMemContextPack(memoryService, args) {
   );
   const sessions = summarizeSessions(timelineEvents, sessionLimit);
   const recentSessionIds = new Set(sessions.map((session) => session.sessionId));
-  const relevantMemories = selectContextPackMemories(searchResult.memories, {
+  const relevantMemories = selectContextPackMemories(search.memories, {
     genericContinuationQuery,
     topK,
     recentSessionIds,
@@ -20251,11 +20671,15 @@ async function handleMemContextPack(memoryService, args) {
     `- Recent sessions shown: ${Math.min(sessionLimit, sessions.length)}`
   ];
   if (freshnessRun) {
+    const refreshMode = autoFreshnessRefresh ? "auto" : "attempted";
     lines.push(
-      `- Freshness refresh: attempted before retrieval (${freshnessRun.sources.join(", ")})`,
+      `- Freshness refresh: ${refreshMode} before retrieval (${freshnessRun.sources.join(", ")})`,
       `- Refresh limits: sessions=${freshnessRun.sessionLimit} messages=${freshnessRun.messageLimit} force=${freshnessRun.force ? "yes" : "no"} embeddings=${freshnessRun.processEmbeddings ? `processed ${freshnessRun.embeddingsProcessed ?? 0}` : "skipped"}`
     );
   }
+  if (search.warning) {
+    lines.push(`- ${search.warning}`);
+  }
   if (genericContinuationQuery) {
     lines.push("- Generic continuation query: recent project timeline prioritized.");
   }
@@ -20495,7 +20919,7 @@ function shouldShowContextPackTimelineEvent(event, projectPath, genericContinuat
     return false;
   if (event.eventType === "tool_observation")
     return false;
-  if (mentionsDifferentWorkspaceProject(content, projectPath))
+  if (eventBelongsToDifferentProject(event, projectPath))
     return false;
   if (genericContinuationQuery && isGenericContinuationQuery(content))
     return false;
@@ -20507,7 +20931,7 @@ function shouldShowContextPackMemory(memory, options) {
     return false;
   if (memory.event.eventType === "tool_observation")
     return false;
-  if (mentionsDifferentWorkspaceProject(content, options.projectPath))
+  if (eventBelongsToDifferentProject(memory.event, options.projectPath))
     return false;
   if (!options.genericContinuationQuery)
     return true;
@@ -20519,6 +20943,54 @@ function shouldShowContextPackMemory(memory, options) {
     return memory.score >= GENERIC_RECENT_MEMORY_MIN_SCORE;
   return memory.score >= GENERIC_STALE_MEMORY_MIN_SCORE;
 }
+function eventBelongsToDifferentProject(event, projectPath) {
+  if (!projectPath)
+    return false;
+  const metadata = event.metadata || {};
+  const metadataProjectRefs = metadataProjectReferenceValues(metadata);
+  if (metadataProjectRefs.length > 0) {
+    return !metadataProjectRefs.some((value) => projectReferenceMatches(value, projectPath));
+  }
+  if (isUnscopedImportedHistory(metadata))
+    return true;
+  return mentionsDifferentWorkspaceProject(event.content || "", projectPath);
+}
+function isUnscopedImportedHistory(metadata) {
+  return typeof metadata.importedFrom === "string" || typeof metadata.sourceSessionId === "string" || typeof metadata.sourceSessionHash === "string" || typeof metadata.transcriptPath === "string";
+}
+var PROJECT_METADATA_KEYS = /* @__PURE__ */ new Set([
+  "projectPath",
+  "sourceProjectPath",
+  "workspacePath",
+  "sourceWorkspacePath",
+  "cwd",
+  "sourceCwd",
+  "currentWorkingDirectory",
+  "projectRoot",
+  "repoPath",
+  "repositoryPath"
+]);
+function metadataProjectReferenceValues(metadata) {
+  const values = [];
+  for (const [key, value] of Object.entries(metadata)) {
+    if (!PROJECT_METADATA_KEYS.has(key))
+      continue;
+    if (typeof value === "string" && value.trim().length > 0) {
+      values.push(value.trim());
+    }
+  }
+  return values;
+}
+function projectReferenceMatches(reference, projectPath) {
+  const normalizedReference = normalizeProjectReference(reference);
+  const normalizedProjectPath = normalizeProjectReference(projectPath);
+  if (normalizedReference === normalizedProjectPath)
+    return true;
+  return normalizedReference.startsWith(`${normalizedProjectPath}/`);
+}
+function normalizeProjectReference(value) {
+  return value.trim().replace(/\\/g, "/").replace(/\/+$/g, "").toLowerCase();
+}
 function mentionsDifferentWorkspaceProject(content, projectPath) {
   const currentProject = basenameOfPath(projectPath);
   if (!currentProject)
@@ -20749,9 +21221,11 @@ function formatMetadataValue(value) {
 function textResult(text) {
   return { content: [{ type: "text", text }] };
 }
-async function handleMemStats(memoryService) {
+async function handleMemStats(memoryService, args) {
   const stats = await memoryService.getStats();
   const recentEvents = await memoryService.getRecentEvents(1e4);
+  const outboxStats = await readMcpOutboxStats(memoryService);
+  const storageView = buildMcpStatsStorageView(optionalString(args.projectPath));
   const uniqueSessions = new Set(recentEvents.map((e) => e.sessionId));
   const lines = [
     "## Memory Statistics",
@@ -20760,6 +21234,19 @@ async function handleMemStats(memoryService) {
     `- **Total Vectors**: ${stats.vectorCount}`,
     `- **Sessions**: ${uniqueSessions.size}`,
     "",
+    "### Storage View / Freshness",
+    "",
+    `- Storage View: ${storageView.storageView}`,
+    `- Storage Path Label: ${storageView.storagePathLabel}`,
+    `- Embedder Model: ${storageView.embedderModel}`,
+    `- Vector Table Dimension: ${storageView.vectorTableDimension}`,
+    `- Pending Embeddings: ${outboxStats.embedding.pending}`,
+    `- Embedding Outbox: pending=${outboxStats.embedding.pending}, processing=${outboxStats.embedding.processing}, failed=${outboxStats.embedding.failed}, total=${outboxStats.embedding.total}`,
+    `- Vector Outbox Pending: ${outboxStats.vector.pending}`,
+    `- Vector Outbox: pending=${outboxStats.vector.pending}, processing=${outboxStats.vector.processing}, failed=${outboxStats.vector.failed}, total=${outboxStats.vector.total}`,
+    "- MCP/CLI parity: CLI `stats -p <project>` and MCP `mem-stats(projectPath=...)` should use this same storage view label.",
+    "- Restart guidance: if CLI and MCP counts differ for this storage view after import/build, restart the long-lived MCP/Hermes gateway process.",
+    "",
     "### Events by Type",
     ""
   ];
@@ -20774,6 +21261,35 @@ async function handleMemStats(memoryService) {
     content: [{ type: "text", text: lines.join("\n") }]
   };
 }
+async function readMcpOutboxStats(memoryService) {
+  try {
+    return await memoryService.getOutboxStats();
+  } catch {
+    return {
+      embedding: { pending: 0, processing: 0, failed: 0, total: 0 },
+      vector: { pending: 0, processing: 0, failed: 0, total: 0 }
+    };
+  }
+}
+function buildMcpStatsStorageView(projectPath) {
+  const embedderModel = process.env.CLAUDE_MEMORY_EMBEDDING_MODEL || DEFAULT_EMBEDDING_MODEL;
+  const requestedProjectPath = projectPath?.trim();
+  if (requestedProjectPath) {
+    const projectHash = hashProjectPath(requestedProjectPath);
+    return {
+      storageView: `project:${projectHash}`,
+      storagePathLabel: `~/.claude-code/memory/projects/${projectHash}`,
+      embedderModel,
+      vectorTableDimension: "unknown (not recorded in current vector metadata)"
+    };
+  }
+  return {
+    storageView: "global",
+    storagePathLabel: "~/.claude-code/memory",
+    embedderModel,
+    vectorTableDimension: "unknown (not recorded in current vector metadata)"
+  };
+}
 
 // src/extensions/mcp/index.ts
 var server = new Server(