claude-mem-lite 2.1.6 → 2.2.2

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "2.1.6",
+  "version": "2.2.0",
   "description": "Lightweight persistent memory system for Claude Code — FTS5 search, episode batching, error-triggered recall",
   "author": {
     "name": "sdsrss"

package/dispatch-feedback.mjs

@@ -183,13 +183,12 @@ export async function collectFeedback(db, sessionId, sessionEvents = []) {
     const invocations = getSessionInvocations(db, sessionId);
     if (invocations.length === 0) return;
 
-    const outcome = detectOutcome(sessionEvents);
-
     for (const inv of invocations) {
       // Skip if already collected (prevents double-collection from stop + session-start)
       if (inv.outcome) continue;
 
       const adopted = detectAdoption(inv, sessionEvents);
+      const outcome = adopted ? detectOutcome(sessionEvents) : 'ignored';
       const score = adopted ? (outcome === 'success' ? 1.0 : outcome === 'partial' ? 0.5 : 0.2) : 0;
 
       // Update invocation record

package/dispatch-inject.mjs

@@ -24,7 +24,7 @@ const ALLOWED_BASES = [
 
 function isAllowedPath(filePath) {
   if (!filePath) return false;
-  return ALLOWED_BASES.some(base => filePath.startsWith(base));
+  return ALLOWED_BASES.some(base => filePath === base || filePath.startsWith(base + '/'));
 }
 
 // ─── Template Detection ──────────────────────────────────────────────────────

package/dispatch.mjs

@@ -5,17 +5,14 @@
 // Tier 3: Haiku semantic dispatch (~500ms, only when needed)
 
 import { basename, join } from 'path';
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
 import { retrieveResources, buildEnhancedQuery, buildQueryFromText, DISPATCH_SYNONYMS } from './registry-retriever.mjs';
 import { renderInjection } from './dispatch-inject.mjs';
 import { updateResourceStats, recordInvocation } from './registry.mjs';
 import { callHaikuJSON } from './haiku-client.mjs';
 import { debugCatch, truncate } from './utils.mjs';
-import { DB_DIR } from './schema.mjs';
-
-// Duplicated from hook-shared.mjs to avoid circular import (dispatch ← hook ← hook-shared)
-const RUNTIME_DIR = join(DB_DIR, 'runtime');
-try { if (!existsSync(RUNTIME_DIR)) mkdirSync(RUNTIME_DIR, { recursive: true }); } catch {}
+import { peekToolEvents, RUNTIME_DIR } from './hook-shared.mjs';
+import { detectActiveSuite, shouldRecommendForStage, detectExplicitRequest, inferCurrentStage } from './dispatch-workflow.mjs';
 
 // ─── Constants ───────────────────────────────────────────────────────────────
 
@@ -28,6 +25,10 @@ const READ_ONLY_TOOLS = new Set([
 export const COOLDOWN_MINUTES = 60;
 export const SESSION_RECOMMEND_CAP = 3;
 
+// Minimum absolute BM25 composite score to recommend. Typical good matches score 5-50;
+// this filters only near-zero noise matches from incidental text overlap.
+export const BM25_MIN_THRESHOLD = 1.5;
+
 // ─── Haiku Circuit Breaker ──────────────────────────────────────────────────
 // Prevents cascading latency when Haiku API is down or slow.
 // After BREAKER_THRESHOLD consecutive failures, disable for BREAKER_RESET_MS.
@@ -494,7 +495,7 @@ function inferTechFromPrompt(prompt) {
     [/\b(typescript|ts)\b/i, 'typescript'],
     [/\b(python|django|flask|fastapi)\b/i, 'python'],
     [/\b(rust|cargo)\b/i, 'rust'],
-    [/\b(golang|go\s+\w+)\b/i, 'go'],
+    [/\b(golang|go\s+(?:build|test|run|get|mod|install|fmt|vet|generate|clean|work|tool))\b/i, 'go'],
     [/\b(java|spring|maven|gradle)\b/i, 'java'],
     [/\b(ruby|rails)\b/i, 'ruby'],
     [/\b(php|laravel|symfony)\b/i, 'php'],
@@ -645,7 +646,7 @@ export function isRecentlyRecommended(db, resourceId, sessionId) {
 
     // Already recommended in this session (session dedup)
     const sessionHit = db.prepare(
-      'SELECT 1 FROM invocations WHERE resource_id = ? AND session_id = ? LIMIT 1'
+      'SELECT 1 FROM invocations WHERE resource_id = ? AND session_id = ? AND recommended = 1 LIMIT 1'
     ).get(resourceId, sessionId);
     if (sessionHit) return true;
   }
@@ -691,7 +692,7 @@ function reRankByKeywords(results, rawKeywords) {
  * @param {object[]} results FTS5 results with recommend_count/adopt_count
  * @returns {object[]} Filtered results with decayed scores
  */
-function applyAdoptionDecay(results) {
+function applyAdoptionDecay(results, db) {
   return results.map(r => {
     const recs = r.recommend_count || 0;
     const adopts = r.adopt_count || 0;
@@ -699,15 +700,24 @@ function applyAdoptionDecay(results) {
 
     const rate = (adopts + 1) / (recs + 2); // Laplace smoothing
     let multiplier = 1.0;
-    if (recs > 100 && rate < 0.01) multiplier = 0;       // Block entirely
-    else if (recs > 50 && rate < 0.02) multiplier = 0.1;  // Heavy penalty
-    else if (recs > 20 && rate < 0.05) multiplier = 0.3;  // Light penalty
+    if (recs > 100 && rate < 0.01) multiplier = 0.05;   // Near-block but not permanent
+    else if (recs > 50 && rate < 0.02) multiplier = 0.15;
+    else if (recs > 20 && rate < 0.05) multiplier = 0.4;
+
+    // Recent rejection boost: extra penalty for resources rejected many times recently
+    if (db && multiplier < 1) {
+      try {
+        const recentRejects = db.prepare(
+          `SELECT COUNT(*) as cnt FROM invocations WHERE resource_id = ? AND adopted = 0 AND created_at > datetime('now', '-7 days')`
+        ).get(r.id)?.cnt || 0;
+        if (recentRejects >= 10) multiplier *= 0.3;
+        else if (recentRejects >= 5) multiplier *= 0.5;
+      } catch (e) { debugCatch(e, 'applyAdoptionDecay-recentRejects'); }
+    }
 
-    if (multiplier === 0) return null;
+    if (multiplier < 0.01) return null;
     if (multiplier < 1) {
-      // BM25 scores are negative (more negative = more relevant).
-      // To penalize: divide by multiplier to make less negative (worse rank).
-      return { ...r, relevance: r.relevance / multiplier, _decayed: true };
+      return { ...r, composite_score: (r.composite_score ?? r.relevance) * multiplier, _decayed: true };
     }
     return r;
   }).filter(Boolean);
@@ -722,6 +732,15 @@ function applyAdoptionDecay(results) {
  * @returns {object[]} Filtered results that pass the gate
  */
 function passesConfidenceGate(results, signals) {
+  // BM25 absolute minimum: filter out weak text matches regardless of intent.
+  // Only apply when enough results exist (BM25 IDF is unreliable with < 3 matches).
+  if (results.length >= 3) {
+    results = results.filter(r => {
+      const score = Math.abs(r.composite_score ?? r.relevance);
+      return score >= BM25_MIN_THRESHOLD;
+    });
+  }
+
   // signals.intent is a comma-separated string (e.g. "test,fix"), not an array
   const intentTokens = typeof signals?.intent === 'string'
     ? signals.intent.split(',').filter(Boolean)
@@ -748,13 +767,19 @@ function passesConfidenceGate(results, signals) {
 
 /**
  * Dispatch on SessionStart: analyze user prompt, return best resource suggestion.
+ * Only dispatches when continuing from a previous session (handoff).
+ * Cold starts (no previous session) showed 0% adoption — skip dispatch entirely.
  * @param {Database} db Registry database
  * @param {string} userPrompt User's prompt text
  * @param {string} [sessionId] Session identifier for dedup
+ * @param {Object} [options]
+ * @param {boolean} [options.hasHandoff=false] Whether a previous session handoff exists
  * @returns {Promise<string|null>} Injection text or null
  */
-export async function dispatchOnSessionStart(db, userPrompt, sessionId) {
-  if (!userPrompt || !db) return null;
+export async function dispatchOnSessionStart(db, userPrompt, sessionId, { hasHandoff = false } = {}) {
+  if (!db) return null;
+  if (!hasHandoff) return null;  // Only dispatch when continuing from a previous session
+  if (!userPrompt) return null;  // Prompt still required for FTS query
 
   try {
     const projectDomains = detectProjectDomains();
@@ -783,7 +808,7 @@ export async function dispatchOnSessionStart(db, userPrompt, sessionId) {
     }
 
     results = reRankByKeywords(results, signals.rawKeywords);
-    results = applyAdoptionDecay(results);
+    results = applyAdoptionDecay(results, db);
     results = passesConfidenceGate(results, signals);
     results = results.slice(0, 3);
 
@@ -796,7 +821,7 @@ export async function dispatchOnSessionStart(db, userPrompt, sessionId) {
       if (haikuResult?.query) {
         const haikuQuery = buildQueryFromText(haikuResult.query);
         if (haikuQuery) {
-          const haikuResults = retrieveResources(db, haikuQuery, {
+          let haikuResults = retrieveResources(db, haikuQuery, {
             type: haikuResult.type === 'either' ? undefined : haikuResult.type,
             limit: 3,
             projectDomains,
@@ -804,7 +829,7 @@ export async function dispatchOnSessionStart(db, userPrompt, sessionId) {
           if (haikuResults.length > 0) {
             // Apply same post-processing as Tier2 to prevent zombie/low-confidence bypass
             haikuResults = reRankByKeywords(haikuResults, signals.rawKeywords);
-            haikuResults = applyAdoptionDecay(haikuResults);
+            haikuResults = applyAdoptionDecay(haikuResults, db);
             haikuResults = passesConfidenceGate(haikuResults, signals);
             if (haikuResults.length > 0) results = haikuResults;
           }
@@ -848,14 +873,46 @@ export async function dispatchOnSessionStart(db, userPrompt, sessionId) {
  * @param {string} [sessionId] Session identifier for dedup
  * @returns {Promise<string|null>} Injection text or null
  */
-export async function dispatchOnUserPrompt(db, userPrompt, sessionId) {
+export async function dispatchOnUserPrompt(db, userPrompt, sessionId, { sessionEvents } = {}) {
   if (!userPrompt || !db) return null;
 
   try {
+    // 1. Explicit request → highest priority, bypass all restrictions
+    const explicit = detectExplicitRequest(userPrompt);
+    if (explicit.isExplicit) {
+      const textQuery = buildQueryFromText(explicit.searchTerm);
+      if (textQuery) {
+        const explicitResults = retrieveResources(db, textQuery, { limit: 3, projectDomains: detectProjectDomains() });
+        if (explicitResults.length > 0) {
+          const best = explicitResults[0];
+          if (!sessionId || !isRecentlyRecommended(db, best.id, sessionId)) {
+            recordInvocation(db, { resource_id: best.id, session_id: sessionId, trigger: 'user_prompt', tier: 1, recommended: 1 });
+            updateResourceStats(db, best.id, 'recommend_count');
+            return renderInjection(best);
+          }
+        }
+      }
+    }
+
+    // 2. Suite auto-flow protection
+    const events = sessionEvents || peekToolEvents();
+    const activeSuite = detectActiveSuite(events);
+
     const projectDomains = detectProjectDomains();
 
     // Intent-aware enhanced query (column-targeted)
     const signals = extractContextSignals({ tool_name: '_user_prompt' }, { userPrompt });
+
+    // Check if active suite covers the current stage
+    if (activeSuite) {
+      const currentStage = inferCurrentStage(signals.primaryIntent, activeSuite);
+      if (currentStage) {
+        const { shouldRecommend } = shouldRecommendForStage(activeSuite, currentStage);
+        if (!shouldRecommend) return null;
+      }
+    }
+
+    // 3. Normal FTS flow
     const enhancedQuery = buildEnhancedQuery(signals);
 
     // Fetch extra results when rawKeywords are present — the top-3 by BM25 may be
@@ -882,21 +939,14 @@ export async function dispatchOnUserPrompt(db, userPrompt, sessionId) {
     // match those keywords. "帮我做一下SEO审查" → rawKeywords=["seo"] → SEO audit
     // resources should rank above generic code-review resources.
     results = reRankByKeywords(results, signals.rawKeywords);
-    results = applyAdoptionDecay(results);
+    results = applyAdoptionDecay(results, db);
     results = passesConfidenceGate(results, signals);
     results = results.slice(0, 3);
 
     if (results.length === 0) return null;
 
-    // Skip if low confidence (no Haiku fallback — stay fast).
-    // Exception: when results match the user's raw domain keywords (e.g. "seo"),
-    // close BM25 scores indicate "multiple equally good options in the right domain"
-    // rather than "ambiguous/wrong match". Trust the domain match.
-    if (needsHaikuDispatch(results)) {
-      const hasKeywordMatch = signals.rawKeywords?.length > 0 && results.some(r =>
-        signals.rawKeywords.some(kw => (r.intent_tags || '').toLowerCase().includes(kw)));
-      if (!hasKeywordMatch) return null;
-    }
+    // Low confidence → skip (no Haiku in user_prompt path — stay fast)
+    if (needsHaikuDispatch(results)) return null;
 
     // Filter by cooldown + session dedup (prevents double-recommend with SessionStart)
     const viable = sessionId
@@ -939,6 +989,18 @@ export async function dispatchOnPreToolUse(db, event, sessionCtx = {}) {
 
     // Tier 1: Extract context signals
     const signals = extractContextSignals(event, sessionCtx);
+
+    // Suite protection: if a suite auto-flow is active, suppress recommendations
+    // for stages the suite already covers
+    const events = peekToolEvents();
+    const activeSuite = detectActiveSuite(events);
+    if (activeSuite) {
+      const stage = inferCurrentStage(signals.primaryIntent, activeSuite);
+      if (stage) {
+        const { shouldRecommend } = shouldRecommendForStage(activeSuite, stage);
+        if (!shouldRecommend) return null;
+      }
+    }
     const query = buildEnhancedQuery(signals);
     if (!query) return null;
 
@@ -946,7 +1008,7 @@ export async function dispatchOnPreToolUse(db, event, sessionCtx = {}) {
 
     // Tier 2: FTS5 retrieval
     let results = retrieveResources(db, query, { limit: 3, projectDomains });
-    results = applyAdoptionDecay(results);
+    results = applyAdoptionDecay(results, db);
     results = passesConfidenceGate(results, signals);
     if (results.length === 0) return null;
 

package/hook-context.mjs

@@ -154,7 +154,7 @@ export function updateClaudeMd(contextBlock) {
   const startIdx = content.indexOf(startTag);
   const endIdx = content.indexOf(endTag);
 
-  if (startIdx !== -1 && endIdx !== -1) {
+  if (startIdx !== -1 && endIdx !== -1 && startIdx < endIdx) {
     // Replace existing section in-place — preserves surrounding content (including hint if present)
     content = content.slice(0, startIdx) + newSection + content.slice(endIdx + endTag.length);
   } else if (content.length > 0) {

package/hook-episode.mjs

@@ -210,13 +210,31 @@ export function mergePendingEntries(episode) {
 
 /**
  * Check if an episode has significant content worth processing with LLM.
- * Significant = contains file edits or Bash errors.
+ * Significant = contains file edits, Bash errors, or a review/research pattern
+ * (5+ Read/Grep entries indicate investigation worth recording).
  * @param {object} episode The episode to check
  * @returns {boolean} true if the episode has significant content
  */
 export function episodeHasSignificantContent(episode) {
-  return episode.entries.some(e =>
+  // 1. File edits or Bash errors → always significant
+  const hasEditsOrErrors = episode.entries.some(e =>
     EDIT_TOOLS.has(e.tool) ||
     (e.tool === 'Bash' && e.isError)
   );
+  if (hasEditsOrErrors) return true;
+
+  // 2. Important files touched (config, schema, security, migration)
+  // Checks episode.files (all touched files, including reads) — catches important-file investigation
+  const allFiles = episode.files || [];
+  const hasImportantFile = allFiles.some(f =>
+    /\.(env|yml|yaml|toml|lock|sql|prisma|proto)$/.test(f) ||
+    /(config|schema|migration|auth|security)/i.test(f)
+  );
+  if (hasImportantFile) return true;
+
+  // 3. Research pattern: reading many files indicates investigation
+  const readCount = episode.entries.filter(e =>
+    e.tool === 'Read' || e.tool === 'Grep'
+  ).length;
+  return readCount >= 5;
 }

package/hook-llm.mjs

@@ -183,6 +183,47 @@ export function buildDegradedTitle(episode) {
   return desc.replace(/ → (?:ERROR: )?\{.*$/, hasError ? ' (error)' : '');
 }
 
+/**
+ * Build a rule-based observation from episode metadata for immediate DB persistence.
+ * Used as pre-save (before LLM) and as fallback when LLM is unavailable.
+ * @param {object} episode Episode with entries, files, filesRead arrays
+ * @returns {object} Observation object ready for saveObservation()
+ */
+export function buildImmediateObservation(episode) {
+  const hasError = episode.entries.some(e => e.isError);
+  const hasEdit = episode.entries.some(e => EDIT_TOOLS.has(e.tool));
+  const readCount = episode.entries.filter(e => e.tool === 'Read' || e.tool === 'Grep').length;
+  const isReviewPattern = !hasEdit && !hasError && readCount >= 5;
+  const inferredType = hasError ? 'bugfix' : hasEdit ? 'change' : 'discovery';
+  const fileList = (episode.files || []).map(f => basename(f)).join(', ') || '(multiple)';
+
+  // Review/research episodes: use a descriptive title with file count
+  let title;
+  if (isReviewPattern) {
+    const allFiles = [...new Set([
+      ...(episode.files || []),
+      ...(episode.filesRead || []),
+    ])].map(f => basename(f));
+    const names = allFiles.slice(0, 4).join(', ');
+    const suffix = allFiles.length > 4 ? ` +${allFiles.length - 4} more` : '';
+    title = truncate(`Reviewed ${allFiles.length} files: ${names}${suffix}`, 120);
+  } else {
+    title = truncate(buildDegradedTitle(episode), 120);
+  }
+
+  return {
+    type: inferredType,
+    title,
+    subtitle: fileList,
+    narrative: episode.entries.map(e => e.desc).join('; '),
+    concepts: [],
+    facts: [],
+    files: episode.files,
+    filesRead: episode.filesRead || [],
+    importance: isReviewPattern ? Math.max(2, computeRuleImportance(episode)) : computeRuleImportance(episode),
+  };
+}
+
 // ─── Background: LLM Episode Extraction (Tier 2 F) ──────────────────────────
 
 export async function handleLLMEpisode() {
@@ -226,7 +267,7 @@ Error: ${e.isError ? 'yes' : 'no'}
 
 JSON: {"type":"decision|bugfix|feature|refactor|discovery|change","title":"concise ≤80 char description","narrative":"what changed, why, and outcome (2-3 sentences)","concepts":["kw1","kw2"],"facts":["fact1","fact2"],"importance":1}
 Facts: each MUST be (1) atomic—one claim, (2) self-contained—no pronouns, include file/function name, (3) specific—"refreshToken() in auth.ts:45 uses 1h TTL" not "handles tokens"
-importance: 1=routine, 2=notable (error fix, arch decision, config change), 3=critical (breaking change, security fix, data migration)`;
+importance: 0=not worth saving (pure browsing, trivial query, no learning value), 1=routine, 2=notable (error fix, arch decision, config change), 3=critical (breaking change, security fix, data migration)`;
   } else {
     const actionList = episode.entries.map((e, i) =>
       `${i + 1}. [${e.tool}] ${e.desc}${e.isError ? ' (ERROR)' : ''}`
@@ -241,7 +282,7 @@ ${actionList}
 
 JSON: {"type":"decision|bugfix|feature|refactor|discovery|change","title":"coherent ≤80 char summary","narrative":"what was done, why, and outcome (3-5 sentences)","concepts":["keyword1","keyword2"],"facts":["specific fact 1","specific fact 2"],"importance":1}
 Facts: each MUST be (1) atomic—one claim, (2) self-contained—no pronouns, include file/function name, (3) specific—"refreshToken() in auth.ts:45 uses 1h TTL" not "handles tokens"
-importance: 1=routine, 2=notable (error fix, arch decision, config change), 3=critical (breaking change, security fix, data migration)`;
+importance: 0=not worth saving (pure browsing, trivial query, no learning value), 1=routine, 2=notable (error fix, arch decision, config change), 3=critical (breaking change, security fix, data migration)`;
   }
 
   const ruleImportance = computeRuleImportance(episode);
@@ -260,6 +301,21 @@ importance: 1=routine, 2=notable (error fix, arch decision, config change), 3=cr
     }
 
     if (parsed && parsed.title) {
+      // Discard if LLM judges observation has no learning value
+      if (parsed.importance === 0 || parsed.importance === '0') {
+        debugLog('DEBUG', 'llm-episode', `Discarded low-value observation: ${parsed.title}`);
+        // If pre-saved, delete it too
+        if (episode.savedId) {
+          const ddb = openDb();
+          if (ddb) {
+            try { ddb.prepare('DELETE FROM observations WHERE id = ?').run(episode.savedId); }
+            finally { ddb.close(); }
+          }
+        }
+        try { unlinkSync(tmpFile); } catch {}
+        return;
+      }
+
       obs = {
         type: validTypes.has(parsed.type) ? parsed.type : 'change',
         title: truncate(parsed.title, 120),
@@ -282,20 +338,7 @@ importance: 1=routine, 2=notable (error fix, arch decision, config change), 3=cr
       try { unlinkSync(tmpFile); } catch {}
       return;
     }
-    const hasError = episode.entries.some(e => e.isError);
-    const hasEdit = episode.entries.some(e => EDIT_TOOLS.has(e.tool));
-    const inferredType = hasError ? 'bugfix' : hasEdit ? 'change' : 'discovery';
-    obs = {
-      type: inferredType,
-      title: truncate(buildDegradedTitle(episode), 120),
-      subtitle: fileList,
-      narrative: episode.entries.map(e => e.desc).join('; '),
-      concepts: [],
-      facts: [],
-      files: episode.files,
-      filesRead: episode.filesRead || [],
-      importance: ruleImportance,
-    };
+    obs = buildImmediateObservation(episode);
   }
 
   const db = openDb();
@@ -371,16 +414,25 @@ export async function handleLLMSummary() {
     if (recentObs.length < 1) return;
 
     const obsList = recentObs.map((o, i) =>
-      `${i + 1}. [${o.type}] ${o.title}${o.narrative ? ': ' + truncate(o.narrative, 80) : ''}`
+      `${i + 1}. [${o.type}] ${o.title}${o.narrative ? ': ' + truncate(o.narrative, 200) : ''}`
     ).join('\n');
 
+    // Include user prompts for richer context
+    const userPrompts = db.prepare(`
+      SELECT prompt_text FROM user_prompts
+      WHERE content_session_id = ? ORDER BY prompt_number ASC LIMIT 10
+    `).all(sessionId).map(p => truncate(p.prompt_text, 300));
+    const promptCtx = userPrompts.length > 0
+      ? `\nUser requests: ${userPrompts.join(' → ')}\n`
+      : '';
+
     const prompt = `Summarize this coding session. Return ONLY valid JSON, no markdown fences.
 
-Project: ${project}
+Project: ${project}${promptCtx}
 Observations (${recentObs.length} total):
 ${obsList}
 
-JSON: {"request":"what the user was working on","investigated":"what was explored/analyzed","learned":"key findings","completed":"what was accomplished","next_steps":"suggested follow-up"}`;
+JSON: {"request":"what the user was working on","completed":"specific items accomplished with file names","remaining_items":"specific unfinished items from the original request — compare investigation scope with actual changes to infer what was NOT yet done; be precise with file:issue format, or empty string if all done","next_steps":"suggested follow-up"}`;
 
     if (!(await acquireLLMSlot())) {
       debugLog('WARN', 'llm-summary', 'semaphore timeout, skipping summary');
@@ -398,12 +450,13 @@ JSON: {"request":"what the user was working on","investigated":"what was explore
     if (llmParsed && llmParsed.request) {
       const now = new Date();
       db.prepare(`
-        INSERT INTO session_summaries (memory_session_id, project, request, investigated, learned, completed, next_steps, files_read, files_edited, notes, created_at, created_at_epoch)
-        VALUES (?, ?, ?, ?, ?, ?, ?, '[]', '[]', '', ?, ?)
+        INSERT INTO session_summaries (memory_session_id, project, request, investigated, learned, completed, next_steps, remaining_items, files_read, files_edited, notes, created_at, created_at_epoch)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, '[]', '[]', '', ?, ?)
       `).run(
         sessionId, project,
         llmParsed.request || '', llmParsed.investigated || '', llmParsed.learned || '',
         llmParsed.completed || '', llmParsed.next_steps || '',
+        llmParsed.remaining_items || '',
         now.toISOString(), now.getTime()
       );
     }

package/hook-shared.mjs

@@ -179,6 +179,20 @@ export function readAndClearToolEvents() {
   }
 }
 
+/**
+ * Read tracked tool events WITHOUT clearing the file.
+ * Used by dispatch to detect active suites mid-session.
+ * @returns {object[]} Array of tool event objects
+ */
+export function peekToolEvents() {
+  try {
+    const raw = readFileSync(toolEventsFile(), 'utf8');
+    return raw.trim().split('\n').filter(Boolean).map(line => {
+      try { return JSON.parse(line); } catch { return null; }
+    }).filter(Boolean);
+  } catch { return []; }
+}
+
 /**
  * Extract partial response from CLI error output (timeout/error recovery).
  * @param {Error} error The caught error from execFileSync

package/hook.mjs

@@ -10,7 +10,7 @@ import { readFileSync, writeFileSync, unlinkSync, readdirSync, renameSync, statS
 import {
   truncate, typeIcon, inferProject, detectBashSignificance,
   extractErrorKeywords, extractFilePaths, isRelatedToEpisode,
-  makeEntryDesc, scrubSecrets, computeRuleImportance, EDIT_TOOLS, debugCatch, debugLog, fmtTime,
+  makeEntryDesc, scrubSecrets, EDIT_TOOLS, debugCatch, debugLog, fmtTime,
 } from './utils.mjs';
 import {
   readEpisodeRaw, episodeFile,
@@ -29,7 +29,7 @@ import {
   closeRegistryDb, spawnBackground, appendToolEvent, readAndClearToolEvents,
   resetInjectionBudget, hasInjectionBudget, incrementInjection,
 } from './hook-shared.mjs';
-import { handleLLMEpisode, handleLLMSummary, saveObservation, buildDegradedTitle } from './hook-llm.mjs';
+import { handleLLMEpisode, handleLLMSummary, saveObservation, buildImmediateObservation } from './hook-llm.mjs';
 import { searchRelevantMemories } from './hook-memory.mjs';
 import { buildAndSaveHandoff, detectContinuationIntent, renderHandoffInjection } from './hook-handoff.mjs';
 
@@ -89,21 +89,7 @@ function flushEpisode(episode) {
   // LLM background worker will upgrade title/narrative/importance later.
   if (isSignificant) {
     try {
-      const hasError = episode.entries.some(e => e.isError);
-      const hasEdit = episode.entries.some(e => EDIT_TOOLS.has(e.tool));
-      const inferredType = hasError ? 'bugfix' : hasEdit ? 'change' : 'discovery';
-      const fileList = (episode.files || []).map(f => basename(f)).join(', ') || '(multiple)';
-      const obs = {
-        type: inferredType,
-        title: truncate(buildDegradedTitle(episode), 120),
-        subtitle: fileList,
-        narrative: episode.entries.map(e => e.desc).join('; '),
-        concepts: [],
-        facts: [],
-        files: episode.files,
-        filesRead: episode.filesRead || [],
-        importance: computeRuleImportance(episode),
-      };
+      const obs = buildImmediateObservation(episode);
       const id = saveObservation(obs, episode.project, episode.sessionId);
       if (id) episode.savedId = id;
     } catch (e) { debugCatch(e, 'flushEpisode-immediateSave'); }
@@ -160,7 +146,7 @@ async function handlePostToolUse() {
 
   // Skip noise
   if (SKIP_TOOLS.has(tool_name)) return;
-  if (tool_name.startsWith('mem_') || tool_name.startsWith('mcp__mem__')) return;
+  if (tool_name.startsWith('mem_') || tool_name.startsWith('mcp__mem__') || tool_name.startsWith('mcp__plugin_claude-mem-lite')) return;
   if (tool_name.startsWith('mcp__sequential') || tool_name.startsWith('mcp__plugin_context7')) return;
 
   const resp = typeof tool_response === 'string' ? tool_response : JSON.stringify(tool_response || '');
@@ -347,21 +333,7 @@ async function handleStop() {
           // Immediate save: persist rule-based observation to DB before spawning background worker.
           // Without this, data is lost if the background worker fails.
           try {
-            const hasError = episode.entries.some(e => e.isError);
-            const hasEdit = episode.entries.some(e => EDIT_TOOLS.has(e.tool));
-            const inferredType = hasError ? 'bugfix' : hasEdit ? 'change' : 'discovery';
-            const fileList = (episode.files || []).map(f => basename(f)).join(', ') || '(multiple)';
-            const obs = {
-              type: inferredType,
-              title: truncate(buildDegradedTitle(episode), 120),
-              subtitle: fileList,
-              narrative: episode.entries.map(e => e.desc).join('; '),
-              concepts: [],
-              facts: [],
-              files: episode.files,
-              filesRead: episode.filesRead || [],
-              importance: computeRuleImportance(episode),
-            };
+            const obs = buildImmediateObservation(episode);
             const id = saveObservation(obs, episode.project, episode.sessionId);
             if (id) episode.savedId = id;
           } catch (e) { debugCatch(e, 'handleStop-fallback-immediateSave'); }
@@ -397,9 +369,12 @@ async function handleStop() {
   // Always clear event file to prevent stale events accumulating if registry DB is unavailable.
   try {
     const sessionEvents = readAndClearToolEvents();
-    const rdb = getRegistryDb();
-    if (rdb) {
-      await collectFeedback(rdb, sessionId, sessionEvents);
+    // Skip feedback for zero-interaction sessions (no tool events = no meaningful signal)
+    if (sessionEvents.length > 0) {
+      const rdb = getRegistryDb();
+      if (rdb) {
+        await collectFeedback(rdb, sessionId, sessionEvents);
+      }
     }
   } catch (e) { debugCatch(e, 'handleStop-feedback'); }
 
@@ -456,7 +431,7 @@ async function handleSessionStart() {
 
     // ── DB mutations in a transaction (crash-safe consistency) ──
     const staleSessionCutoff = Date.now() - STALE_SESSION_MS;
-    const autoCompressAge = Date.now() - 90 * 86400000; // 90 days
+    const autoCompressAge = Date.now() - 30 * 86400000; // 30 days (accelerated from 90)
 
     db.transaction(() => {
       // Ensure session exists in DB (INSERT OR IGNORE avoids race condition)
@@ -479,7 +454,7 @@ async function handleSessionStart() {
         WHERE status = 'active' AND started_at_epoch < ?
       `).run(staleSessionCutoff);
 
-      // Auto-compress: mark old low-importance observations as compressed (90+ days, importance=1)
+      // Auto-compress: mark old low-importance observations as compressed (30+ days, importance=1)
       // Lightweight: only marks rows, doesn't create summaries (full compression via mem_compress)
       const compressed = db.prepare(`
         UPDATE observations SET compressed_into = -1
@@ -703,8 +678,10 @@ async function handleSessionStart() {
     try {
       const rdb = getRegistryDb();
       if (rdb && hasInjectionBudget()) {
-        const promptCtx = latestSummary?.next_steps || '';
-        const dispatchResult = await dispatchOnSessionStart(rdb, promptCtx, sessionId);
+        // Build prompt context with fallbacks: next_steps → request → completed (empty = no dispatch)
+        const promptCtx = latestSummary?.next_steps || latestSummary?.request || latestSummary?.completed || '';
+        const hasHandoff = !!prevSessionId;  // prevSessionId set when /clear or rapid restart detected
+        const dispatchResult = await dispatchOnSessionStart(rdb, promptCtx, sessionId, { hasHandoff });
         if (dispatchResult) {
           process.stdout.write(dispatchResult + '\n');
           incrementInjection();
@@ -906,6 +883,7 @@ async function handleResourceScan() {
     }
 
     // Upsert changed resources with fallback metadata (no Haiku)
+    let firstErr = true;
     for (const res of toIndex) {
       try {
         upsertResource(rdb, {
@@ -920,7 +898,7 @@ async function handleResourceScan() {
           trigger_patterns: `when user needs ${res.name.replace(/-/g, ' ').replace(/\//g, ' ')}`,
           capability_summary: `${res.type}: ${res.name.replace(/-/g, ' ')}`,
         });
-      } catch {}
+      } catch (e) { if (firstErr) { debugCatch(e, 'handleResourceScan-upsert'); firstErr = false; } }
     }
 
     // Disable resources no longer on filesystem

package/install.mjs

@@ -1217,7 +1217,7 @@ async function install() {
     'haiku-client.mjs', 'utils.mjs', 'schema.mjs', 'package.json', 'skill.md',
     'registry.mjs', 'registry-scanner.mjs', 'registry-indexer.mjs',
     'registry-retriever.mjs', 'resource-discovery.mjs',
-    'dispatch.mjs', 'dispatch-inject.mjs', 'dispatch-feedback.mjs',
+    'dispatch.mjs', 'dispatch-inject.mjs', 'dispatch-feedback.mjs', 'dispatch-workflow.mjs',
   ];
 
   if (IS_DEV) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "2.1.6",
+  "version": "2.2.2",
   "description": "Lightweight persistent memory system for Claude Code",
   "type": "module",
   "engines": {

package/registry-indexer.mjs

@@ -54,13 +54,13 @@ function fallbackExtract(resource) {
     infra: 'infrastructure,devops,cloud',
   };
 
-  let intentTags = '';
+  const intentTagSet = new Set();
   for (const [key, tags] of Object.entries(intentMap)) {
     if (name.includes(key) || content.includes(key)) {
-      intentTags = tags;
-      break;
+      for (const t of tags.split(',')) intentTagSet.add(t);
     }
   }
+  const intentTags = [...intentTagSet].join(',');
 
   // Infer domain tags from content
   const domainPatterns = [

package/registry-retriever.mjs

@@ -197,8 +197,9 @@ export function buildEnhancedQuery(signals) {
   // directly across name, intent_tags, capability_summary, trigger_patterns.
   if (signals.rawKeywords?.length > 0) {
     for (const kw of signals.rawKeywords) {
-      parts.push(`intent_tags:${kw}`);
-      parts.push(kw); // literal, no synonym expansion
+      const safeKw = expandToken(kw);
+      parts.push(`intent_tags:${safeKw}`);
+      parts.push(safeKw);
     }
   }
 
@@ -376,27 +377,31 @@ const COMPOSITE_EXPR = `(
 const COMPOSITE_ORDER = `ORDER BY ${COMPOSITE_EXPR} ASC`;
 
 const SEARCH_SQL = `
-  SELECT r.*,
-    bm25(resources_fts, 5.0, 3.0, 3.0, 2.0, 2.0, 1.0, 1.0, 1.0) AS relevance,
-    ${COMPOSITE_EXPR} AS composite_score
-  FROM resources_fts
-  JOIN resources r ON r.id = resources_fts.rowid
-  WHERE resources_fts MATCH ?
-    AND r.status = 'active'
-  ORDER BY ${COMPOSITE_EXPR} ASC
+  SELECT *, composite_score FROM (
+    SELECT r.*,
+      bm25(resources_fts, 5.0, 3.0, 3.0, 2.0, 2.0, 1.0, 1.0, 1.0) AS relevance,
+      ${COMPOSITE_EXPR} AS composite_score
+    FROM resources_fts
+    JOIN resources r ON r.id = resources_fts.rowid
+    WHERE resources_fts MATCH ?
+      AND r.status = 'active'
+  ) sub
+  ORDER BY composite_score ASC
   LIMIT ?
 `;
 
 const SEARCH_BY_TYPE_SQL = `
-  SELECT r.*,
-    bm25(resources_fts, 5.0, 3.0, 3.0, 2.0, 2.0, 1.0, 1.0, 1.0) AS relevance,
-    ${COMPOSITE_EXPR} AS composite_score
-  FROM resources_fts
-  JOIN resources r ON r.id = resources_fts.rowid
-  WHERE resources_fts MATCH ?
-    AND r.status = 'active'
-    AND r.type = ?
-  ${COMPOSITE_ORDER}
+  SELECT *, composite_score FROM (
+    SELECT r.*,
+      bm25(resources_fts, 5.0, 3.0, 3.0, 2.0, 2.0, 1.0, 1.0, 1.0) AS relevance,
+      ${COMPOSITE_EXPR} AS composite_score
+    FROM resources_fts
+    JOIN resources r ON r.id = resources_fts.rowid
+    WHERE resources_fts MATCH ?
+      AND r.status = 'active'
+      AND r.type = ?
+  ) sub
+  ORDER BY composite_score ASC
   LIMIT ?
 `;
 

package/registry.mjs

@@ -4,7 +4,7 @@
 import Database from 'better-sqlite3';
 import { existsSync, mkdirSync } from 'fs';
 import { dirname } from 'path';
-// debugLog, debugCatch available from utils.mjs if needed
+import { debugCatch } from './utils.mjs';
 
 // ─── Schema ──────────────────────────────────────────────────────────────────
 
@@ -104,7 +104,7 @@ const INVOCATIONS_SCHEMA = `
     tier          INTEGER CHECK(tier IN (1,2,3)),
     recommended   INTEGER DEFAULT 1,
     adopted       INTEGER DEFAULT 0,
-    outcome       TEXT CHECK(outcome IN ('success','partial','failure','skipped',NULL)),
+    outcome       TEXT CHECK(outcome IN ('success','partial','failure','skipped','ignored',NULL)),
     score         REAL,
     created_at    TEXT DEFAULT (datetime('now'))
   );
@@ -178,6 +178,9 @@ export function ensureRegistryDb(dbPath) {
     const schema = db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='invocations'`).get();
     if (schema?.sql && !schema.sql.includes('user_prompt')) {
       db.transaction(() => {
+        // Clean up leftover from previous failed migration attempt
+        const hasOld = db.prepare(`SELECT 1 FROM sqlite_master WHERE type='table' AND name='invocations_old'`).get();
+        if (hasOld) db.exec(`DROP TABLE invocations_old`);
         db.exec(`ALTER TABLE invocations RENAME TO invocations_old`);
         db.exec(INVOCATIONS_SCHEMA);
         db.exec(`INSERT INTO invocations
@@ -187,7 +190,25 @@ export function ensureRegistryDb(dbPath) {
         db.exec(`DROP TABLE invocations_old`);
       })();
     }
-  } catch {}
+  } catch (e) { debugCatch(e, 'ensureRegistryDb-migration'); }
+
+  // Migrate invocations CHECK constraint: add 'ignored' outcome value
+  try {
+    const schema = db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='invocations'`).get();
+    if (schema?.sql && !schema.sql.includes("'ignored'")) {
+      db.transaction(() => {
+        const hasOld = db.prepare(`SELECT 1 FROM sqlite_master WHERE type='table' AND name='invocations_old'`).get();
+        if (hasOld) db.exec(`DROP TABLE invocations_old`);
+        db.exec(`ALTER TABLE invocations RENAME TO invocations_old`);
+        db.exec(INVOCATIONS_SCHEMA);
+        db.exec(`INSERT INTO invocations
+          (id, resource_id, session_id, trigger, tier, recommended, adopted, outcome, score, created_at)
+          SELECT id, resource_id, session_id, trigger, tier, recommended, adopted, outcome, score, created_at
+          FROM invocations_old`);
+        db.exec(`DROP TABLE invocations_old`);
+      })();
+    }
+  } catch (e) { debugCatch(e, 'ensureRegistryDb-ignored-migration'); }
 
   db.exec(PREINSTALLED_SCHEMA);
 
@@ -223,7 +244,7 @@ const UPSERT_SQL = `
  */
 export function upsertResource(db, r) {
   return db.transaction(() => {
-    const result = db.prepare(UPSERT_SQL).run(
+    db.prepare(UPSERT_SQL).run(
       r.name, r.type, r.status || 'active', r.source || 'preinstalled',
       r.repo_url || null, r.repo_stars || 0, r.local_path,
       r.file_hash || null, r.invocation_name || '',
@@ -233,7 +254,6 @@ export function upsertResource(db, r) {
       r.keywords || '', r.tech_stack || '', r.use_cases || '', r.complexity || 'intermediate',
       r.indexed_at || null
     );
-    if (result.changes > 0 && result.lastInsertRowid) return Number(result.lastInsertRowid);
     const row = db.prepare('SELECT id FROM resources WHERE type = ? AND name = ?').get(r.type, r.name);
     return row?.id || 0;
   })();

package/schema.mjs

@@ -97,6 +97,7 @@ const MIGRATIONS = [
   'ALTER TABLE observations ADD COLUMN minhash_sig TEXT',
   'ALTER TABLE observations ADD COLUMN access_count INTEGER DEFAULT 0',
   'ALTER TABLE observations ADD COLUMN compressed_into INTEGER DEFAULT NULL',
+  'ALTER TABLE session_summaries ADD COLUMN remaining_items TEXT',
 ];
 
 /**
@@ -153,7 +154,7 @@ export function initSchema(db) {
 
   // FTS5 full-text search tables + triggers (idempotent)
   ensureFTS(db, 'observations_fts', 'observations', ['title', 'subtitle', 'narrative', 'text', 'facts', 'concepts']);
-  ensureFTS(db, 'session_summaries_fts', 'session_summaries', ['request', 'investigated', 'learned', 'completed', 'next_steps', 'notes']);
+  ensureFTS(db, 'session_summaries_fts', 'session_summaries', ['request', 'investigated', 'learned', 'completed', 'next_steps', 'notes', 'remaining_items']);
   ensureFTS(db, 'user_prompts_fts', 'user_prompts', ['prompt_text']);
 
   return db;
@@ -196,7 +197,12 @@ export function ensureDb() {
   db.pragma('synchronous = NORMAL');
   db.pragma('foreign_keys = OFF'); // Enabled after dedup migration
 
-  return initSchema(db);
+  try {
+    return initSchema(db);
+  } catch (e) {
+    try { db.close(); } catch {}
+    throw e;
+  }
 }
 
 /**
@@ -211,10 +217,12 @@ export function ensureDb() {
  */
 export function rebuildFTS(db) {
   const FTS_TABLES = ['observations_fts', 'session_summaries_fts', 'user_prompts_fts'];
+  const idRe = /^[a-z][a-z0-9_]*$/;
   const rebuilt = [];
   const errors = [];
   for (const fts of FTS_TABLES) {
     try {
+      if (!idRe.test(fts)) { errors.push(`${fts}: invalid identifier`); continue; }
       const exists = db.prepare(`SELECT 1 FROM sqlite_master WHERE type='table' AND name=?`).get(fts);
       if (!exists) { errors.push(`${fts}: not found`); continue; }
       db.exec(`INSERT INTO ${fts}(${fts}) VALUES('rebuild')`);
@@ -233,10 +241,12 @@ export function rebuildFTS(db) {
  */
 export function checkFTSIntegrity(db) {
   const FTS_TABLES = ['observations_fts', 'session_summaries_fts', 'user_prompts_fts'];
+  const idRe = /^[a-z][a-z0-9_]*$/;
   const details = [];
   let healthy = true;
   for (const fts of FTS_TABLES) {
     try {
+      if (!idRe.test(fts)) { details.push(`${fts}: invalid identifier`); healthy = false; continue; }
       const exists = db.prepare(`SELECT 1 FROM sqlite_master WHERE type='table' AND name=?`).get(fts);
       if (!exists) { details.push(`${fts}: missing`); healthy = false; continue; }
       db.exec(`INSERT INTO ${fts}(${fts}) VALUES('integrity-check')`);
@@ -254,7 +264,7 @@ export function ensureFTS(db, ftsName, tableName, columns) {
   if (exists) return;
 
   // Validate identifiers to prevent SQL injection
-  const idRe = /^[a-z_]+$/;
+  const idRe = /^[a-z][a-z0-9_]*$/;
   if (!idRe.test(ftsName) || !idRe.test(tableName) || !columns.every(c => idRe.test(c))) {
     throw new Error(`Invalid identifier in ensureFTS: ${ftsName}, ${tableName}`);
   }

package/scripts/post-tool-use.sh

@@ -50,7 +50,7 @@ case "$tool" in
     exit 0
     ;;
   # Prefix filters
-  mem_*|mcp__mem__*|mcp__sequential*|mcp__plugin_context7*)
+  mem_*|mcp__mem__*|mcp__plugin_claude-mem-lite*|mcp__sequential*|mcp__plugin_context7*)
     exit 0
     ;;
 esac

package/server.mjs

@@ -61,7 +61,7 @@ const RECENCY_HALF_LIFE_MS = 1209600000; // 14 days in milliseconds
 // ─── MCP Server ─────────────────────────────────────────────────────────────
 
 const server = new McpServer(
-  { name: 'claude-mem-lite', version: '2.0.0' },
+  { name: 'claude-mem-lite', version: '2.2.2' },
   {
     instructions: [
       'Proactively search memory to leverage past experience. This is your long-term memory across sessions.',
@@ -83,9 +83,15 @@ const server = new McpServer(
   },
 );
 
+// Track MCP request activity for idle-time cleanup (see idle timer below)
+let lastMcpRequestTime = Date.now();
+let idleCleanupRan = false;
+
 function safeHandler(fn) {
   return async (args, extra) => {
     try {
+      lastMcpRequestTime = Date.now();
+      idleCleanupRan = false;
       return await fn(args, extra);
     } catch (err) {
       return { content: [{ type: 'text', text: `Error: ${err.message}` }], isError: true };
@@ -980,10 +986,58 @@ const walTimer = setInterval(() => {
 }, WAL_CHECKPOINT_INTERVAL);
 walTimer.unref(); // Don't keep process alive just for checkpoints
 
+// ─── Idle-Time Memory Optimization ──────────────────────────────────────────
+// When no MCP requests for 5 minutes, run lightweight DB maintenance.
+// lastMcpRequestTime and idleCleanupRan are declared near safeHandler (which updates them).
+
+const IDLE_THRESHOLD_MS = 5 * 60 * 1000;
+
+const idleTimer = setInterval(() => {
+  if (idleCleanupRan) return;
+  if (Date.now() - lastMcpRequestTime < IDLE_THRESHOLD_MS) return;
+  idleCleanupRan = true;
+
+  try {
+    const thirtyDaysAgo = Date.now() - 30 * 86400000;
+
+    db.transaction(() => {
+      // Delete old low-quality observations (importance<=1, never accessed, 30+ days)
+      const deleted = db.prepare(`
+        DELETE FROM observations
+        WHERE importance <= 1 AND COALESCE(access_count, 0) = 0
+          AND created_at_epoch < ? AND COALESCE(compressed_into, 0) = 0
+      `).run(thirtyDaysAgo);
+      if (deleted.changes > 0) {
+        debugLog('INFO', 'idle-cleanup', `Deleted ${deleted.changes} stale low-quality observations`);
+      }
+
+      // Mark old importance=1 as compressed (30+ days)
+      // NOTE: compressed_into = -1 is an established sentinel meaning "auto-compressed without merge target"
+      // (same pattern used in hook.mjs:456 for time-based compression)
+      const compressed = db.prepare(`
+        UPDATE observations SET compressed_into = -1
+        WHERE COALESCE(compressed_into, 0) = 0 AND importance = 1
+          AND created_at_epoch < ?
+      `).run(thirtyDaysAgo);
+      if (compressed.changes > 0) {
+        debugLog('INFO', 'idle-cleanup', `Compressed ${compressed.changes} old observations`);
+      }
+    })();
+
+    // FTS5 index optimization (outside transaction — WAL-friendly)
+    db.exec("INSERT INTO observations_fts(observations_fts) VALUES('optimize')");
+    debugLog('DEBUG', 'idle-cleanup', 'FTS5 optimize complete');
+  } catch (e) {
+    debugCatch(e, 'idle-cleanup');
+  }
+}, 60000); // Check every minute
+idleTimer.unref();
+
 // ─── Shutdown Cleanup ────────────────────────────────────────────────────────
 
 function shutdown(exitCode = 0) {
   clearInterval(walTimer);
+  clearInterval(idleTimer);
   try { db.pragma('wal_checkpoint(TRUNCATE)'); } catch {}
   try { db.close(); } catch {}
   process.exit(exitCode);

package/utils.mjs

@@ -622,12 +622,11 @@ export function fmtTime(iso) {
  */
 export function isoWeekKey(epochMs) {
   const d = new Date(epochMs);
-  const tmp = new Date(d.getTime());
-  tmp.setHours(0, 0, 0, 0);
-  tmp.setDate(tmp.getDate() + 4 - (tmp.getDay() || 7));
-  const yearStart = new Date(tmp.getFullYear(), 0, 1);
+  const tmp = new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate()));
+  tmp.setUTCDate(tmp.getUTCDate() + 4 - (tmp.getUTCDay() || 7));
+  const yearStart = new Date(Date.UTC(tmp.getUTCFullYear(), 0, 1));
   const weekNum = Math.ceil(((tmp - yearStart) / 86400000 + 1) / 7);
-  const isoYear = tmp.getFullYear();
+  const isoYear = tmp.getUTCFullYear();
   return `${isoYear}-W${String(weekNum).padStart(2, '0')}`;
 }