claude-memory-layer 1.0.31 → 1.0.33

package/dist/services/memory-service.js

@@ -2240,10 +2240,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) {
@@ -2309,6 +2314,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;
@@ -2569,6 +2581,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,
@@ -2610,6 +2624,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);
@@ -2643,6 +2659,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")) {
@@ -3428,8 +3456,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
@@ -3439,11 +3470,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,
@@ -3542,18 +3575,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 || []),
@@ -3579,6 +3615,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) : [],
@@ -3605,6 +3643,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
@@ -3612,15 +3655,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;
     }
@@ -4432,6 +4501,57 @@ var COMMAND_ARTIFACT_PATTERNS = [
   /<local-command-stdout>[\s\S]*?<\/local-command-stdout>/i,
   /<local-command-stderr>[\s\S]*?<\/local-command-stderr>/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
+];
+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",
@@ -4449,6 +4569,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)
@@ -4460,6 +4661,73 @@ function isCommandArtifactQuery(query) {
     return true;
   return COMMAND_ARTIFACT_PATTERNS.some((pattern) => pattern.test(trimmed));
 }
+function isGenericContinuationQuery(query) {
+  const trimmed = query.trim();
+  if (!trimmed)
+    return false;
+  if (!CONTINUATION_QUERY_PATTERNS.some((pattern) => pattern.test(trimmed)))
+    return false;
+  if (extractTechnicalQueryTerms(trimmed).length > 0)
+    return false;
+  const tokens = trimmed.match(/[A-Za-z0-9가-힣#._/-]+/g) ?? [];
+  if (tokens.length > 10)
+    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) => {
@@ -4477,9 +4745,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 = {
@@ -4532,6 +4878,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);
@@ -4548,6 +4895,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,
@@ -4565,6 +4913,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,
@@ -4582,6 +4931,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),
@@ -4598,11 +4948,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");
     }
@@ -4627,7 +4987,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 = {}) {
@@ -4665,8 +5028,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,
@@ -4674,9 +5040,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),
@@ -4703,10 +5072,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));
     }
@@ -5014,7 +5387,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)
@@ -5077,9 +5464,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).
@@ -5504,7 +5891,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,
@@ -7519,8 +7908,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