kodelyth-ecc 1.7.4 → 1.8.0

package/hooks/memory/auto-resolve.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+// =============================================================================
+// Kodelyth ECC — Memory Auto-Resolve Hook (PostToolUse: Write|Edit|MultiEdit)
+//
+// Improvement C — Outcome Tracking
+//
+// Fires after every file write or edit. Checks if the edited file appears in
+// any unresolved memory's files[] list. If it does, that memory's outcome is
+// marked resolved:false — a follow-up edit implies the previous solution
+// didn't fully stick.
+//
+// The same event is propagated to instincts.js so that any structued instinct
+// sourced from the same session gets its confidence downgraded (−0.30),
+// enabling automatic pruning of bad patterns over time.
+//
+// This hook is deliberately silent:
+//   - It never emits output to stdout (would pollute the AI's context).
+//   - It always exits 0 (never blocks a session).
+//   - All writes are atomic enough for the append-only JSONL format.
+//
+// Output contract: pass stdin through to stdout unchanged. Never block.
+// =============================================================================
+
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+
+let raw = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => { raw += chunk; });
+process.stdin.on('end', run);
+setTimeout(() => { if (!process.stdin.readableEnded) run(); }, 150);
+
+function run() {
+  // Always echo stdin — never block the tool result from reaching the AI
+  if (raw) process.stdout.write(raw);
+
+  try {
+    const payload    = raw ? JSON.parse(raw) : {};
+    const toolName   = payload.tool_name || payload.name || '';
+    const toolInput  = payload.tool_input || payload.input || {};
+    const cwd        = payload.cwd || process.cwd();
+
+    // Extract the file path from Write, Edit, or MultiEdit inputs
+    let filePath = toolInput.file_path || toolInput.path || null;
+    if (!filePath && Array.isArray(toolInput.edits) && toolInput.edits[0]) {
+      filePath = toolInput.edits[0].file_path || toolInput.edits[0].path || null;
+    }
+
+    if (!filePath) return; // no file path — nothing to resolve
+
+    const storePath = path.join(__dirname, '..', '..', 'scripts', 'memory', 'store.js');
+    if (!fs.existsSync(storePath)) return;
+
+    const store    = require(storePath);
+    const resolved = store.autoResolveOnEdit(filePath, cwd);
+
+    if (resolved.length > 0) {
+      process.stderr.write(
+        `[ecc:auto-resolve] Marked ${resolved.length} memory/memories resolved:false` +
+        ` after edit to ${path.basename(filePath)}\n`
+      );
+    }
+  } catch (err) {
+    process.stderr.write(`[ecc:auto-resolve] ${err.message}\n`);
+  }
+}

package/hooks/memory/capture-correction.js

@@ -154,6 +154,22 @@ function writeToLessons(corrections, cwd) {
     process.stderr.write(
       `[ecc:correction-capture] ${corrections.length} lesson(s) written to tasks/lessons.md\n`
     );
+
+    // ── Improvement B: also write to structured instinct schema ──────────────
+    try {
+      const instinctsPath = path.join(__dirname, '..', '..', 'scripts', 'memory', 'instincts.js');
+      if (fs.existsSync(instinctsPath)) {
+        const instincts = require(instinctsPath);
+        for (const correction of corrections) {
+          instincts.captureFromCorrection(correction, cwd, 'project');
+        }
+        process.stderr.write(
+          `[ecc:correction-capture] ${corrections.length} instinct(s) written to structured schema\n`
+        );
+      }
+    } catch (instErr) {
+      process.stderr.write(`[ecc:correction-capture] Instinct schema write skipped: ${instErr.message}\n`);
+    }
   } catch (err) {
     process.stderr.write(`[ecc:correction-capture] Could not write lessons: ${err.message}\n`);
   }

package/hooks/memory/capture-stop.js

@@ -10,6 +10,11 @@
 //   /memory review-pending
 // or:
 //   node scripts/memory/cli.js list-pending
+//
+// Improvement A: detects meaningful file writes / git commits in the session
+//   and emits a contextual "should I save what we learned?" prompt.
+//
+// Improvement D: runs instinct decay check — flags instincts unused 30+ days.
 // =============================================================================
 
 'use strict';
@@ -37,7 +42,11 @@ function main() {
 
     const { extractCandidates } = require(path.join(__dirname, '..', '..', 'scripts', 'memory', 'extract'));
     const candidates = extractCandidates(sessionJsonl);
-    if (candidates.length === 0) {
+
+    // ── Improvement A: detect meaningful file writes or git commits ───────────
+    const hadFileWrites = detectFileWrites(sessionJsonl);
+
+    if (candidates.length === 0 && !hadFileWrites) {
       process.exit(0);
     }
 
@@ -45,22 +54,46 @@ function main() {
       || path.join(os.homedir(), '.kodelyth', 'memory');
     if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
 
-    const queueFile = path.join(dir, 'pending-review.jsonl');
     const sessionId = data.session_id || path.basename(sessionJsonl, '.jsonl');
 
-    const lines = candidates.map(c => JSON.stringify({
-      ...c,
-      session_id: sessionId,
-      project_path: data.cwd || process.cwd(),
-      queued_at: new Date().toISOString(),
-    }));
+    if (candidates.length > 0) {
+      const queueFile = path.join(dir, 'pending-review.jsonl');
+      const lines = candidates.map(c => JSON.stringify({
+        ...c,
+        session_id: sessionId,
+        project_path: data.cwd || process.cwd(),
+        queued_at: new Date().toISOString(),
+      }));
+      fs.appendFileSync(queueFile, lines.join('\n') + '\n');
+    }
+
+    // ── Improvement A: build contextual advisory from session activity ────────
+    const parts = [];
+    if (candidates.length > 0) {
+      parts.push(`${candidates.length} memory candidate(s) queued — run "/memory review-pending" to confirm`);
+    }
+    if (hadFileWrites) {
+      parts.push('files written this session — run "/memory save" or "/learn-eval" to save what we learned');
+    }
+
+    // ── Improvement D: decay check — surface stale instincts for review ───────
+    try {
+      const instinctsPath = path.join(__dirname, '..', '..', 'scripts', 'memory', 'instincts.js');
+      if (fs.existsSync(instinctsPath)) {
+        const instincts = require(instinctsPath);
+        const stale = instincts.runDecayCheck();
+        if (stale.length > 0) {
+          parts.push(`${stale.length} instinct(s) unused 30+ days — run "/skill-health" to review stale rules`);
+        }
+      }
+    } catch { /* decay check is best-effort, never block a session */ }
 
-    fs.appendFileSync(queueFile, lines.join('\n') + '\n');
+    if (parts.length > 0) {
+      process.stdout.write(JSON.stringify({
+        message: `Kodelyth Memory: ${parts.join(' | ')}`,
+      }));
+    }
 
-    // Emit advisory message so user sees something happened
-    process.stdout.write(JSON.stringify({
-      message: `Kodelyth Memory: ${candidates.length} candidate(s) queued for review. Run "/memory review-pending" to confirm.`,
-    }));
     process.exit(0);
   } catch (err) {
     process.stderr.write(`kodelyth-memory capture: ${err.message}\n`);
@@ -68,11 +101,34 @@ function main() {
   }
 }
 
+// ── Improvement A: scan session JSONL for Write/Edit tool uses or git commits ─
+function detectFileWrites(sessionJsonl) {
+  try {
+    const lines = fs.readFileSync(sessionJsonl, 'utf8').split('\n').filter(Boolean);
+    for (const line of lines) {
+      let event;
+      try { event = JSON.parse(line); } catch { continue; }
+
+      // Tool use events that write files
+      const toolName = event.name || event.tool_name || '';
+      if (/^(Write|Edit|MultiEdit|NotebookEdit)$/i.test(toolName)) return true;
+
+      // Bash events containing git commit
+      if (/^Bash$/i.test(toolName)) {
+        const input = JSON.stringify(event.input || event.tool_input || '');
+        if (/git\s+commit|git\s+push/i.test(input)) return true;
+      }
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+
 function findLatestClaudeSession(cwd) {
   try {
     const projectsDir = path.join(os.homedir(), '.claude', 'projects');
     if (!fs.existsSync(projectsDir)) return null;
-    // Project dirs are encoded paths
     const encoded = '-' + cwd.replace(/\//g, '-');
     const matches = fs.readdirSync(projectsDir).filter(d => d.endsWith(encoded.slice(-30)));
     if (matches.length === 0) return null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kodelyth-ecc",
-  "version": "1.7.4",
+  "version": "1.8.0",
   "description": "Production-grade AI coding toolkit — 70 agents (incl. devil-mode adversarial crew), 194 skills, 97 commands, parallel multi-agent commands, semantic intent routing, self-learning memory, and a built-in MCP server (16 tools / 6 prompts / 377 resources) that bridges to Claude Desktop, LangGraph, AutoGen, CrewAI, and OpenAI Agents SDK. Works with Claude Code, Windsurf, Cursor, Codex, Antigravity, OpenCode, Cline, RooCode, Aider, Kimi, and Gemini CLI.",
   "author": "Kodelyth <github.com/sifxprime>",
   "license": "MIT",

package/rules/common/agents.md

@@ -1,6 +1,6 @@
 # Agent Orchestration
 
-62 specialist agents are available. Intent routing is always-on — describe your problem in plain words and the right agent is invoked automatically. You can also invoke explicitly: `use <agent-name>`.
+70 specialist agents are available. Intent routing is always-on — describe your problem in plain words and the right agent is invoked automatically. You can also invoke explicitly: `use <agent-name>`.
 
 ## Kodelyth Exclusives
 

package/rules/common/self-improvement-workflow.md

@@ -16,7 +16,7 @@ Enter plan mode for ANY non-trivial task (3+ steps, architectural decisions, or
 
 ## 2. Subagent Strategy
 
-The 61 ECC specialist agents exist so the main context window stays clean:
+The 70 ECC specialist agents exist so the main context window stays clean:
 
 - Offload research, exploration, and parallel analysis to subagents
 - For complex problems: throw more compute via agents, not more tokens in main context
@@ -124,7 +124,7 @@ ECC uses three compounding memory layers — together they make Claude increasin
 - Example: "Last time you had a CORS issue in Express, you added this middleware..."
 
 ### Layer 3 — Intent Routing (`rules/common/agent-intent-routing.md`)
-- Always-on. 61 specialists. Zero setup.
+- Always-on. 70 specialists. Zero setup.
 - Routes your message to the right expert from the first word
 - No agent names needed — just describe the problem
 

package/scripts/dashboard/data.js

@@ -1,6 +1,6 @@
 // scripts/dashboard/data.js
 //
-// Local observability dashboard: pure aggregators (v1.7.4).
+// Local observability dashboard: pure aggregators (v1.8.0).
 //
 // All data the dashboard renders comes from:
 //   - The MCP catalog (filesystem reads of agents/, skills/, commands/, rules/, bundles/)

package/scripts/dashboard/server.js

@@ -1,6 +1,6 @@
 // scripts/dashboard/server.js
 //
-// Local observability dashboard server (v1.7.4).
+// Local observability dashboard server (v1.8.0).
 //
 // HTTP server using ONLY Node.js built-ins. Serves:
 //   GET  /                        → static index.html

package/scripts/memory/instincts.js

@@ -0,0 +1,282 @@
+// =============================================================================
+// Kodelyth ECC — Structured Instinct Schema  (Improvement B)
+//
+// Stores learned instincts as typed JSON records in:
+//   ~/.kodelyth/memory/instincts.jsonl
+//
+// Each instinct has: pattern, trigger, confidence, last_used, outcome, decay.
+// This replaces free-form markdown bullets for machine-readable learning.
+// The lessons.md file is still written for human readability — this runs
+// in parallel, enabling deduplication, conflict detection, and decay.
+//
+// Schema:
+//   id           — deterministic hash (stable across re-runs)
+//   pattern      — short slug: "use-pnpm-not-npm", "no-console-logs"
+//   rule         — full human-readable text of the rule
+//   scope        — "project" | "global"
+//   trigger      — keywords/phrases that activate this instinct
+//   confidence   — 0.0–1.0 (starts at 0.7, confirmed → 1.0, decays with age)
+//   source       — "correction" | "manual" | "evolved"
+//   created      — ISO date
+//   last_used    — ISO date
+//   use_count    — how many sessions this was applied
+//   outcome      — null | "success" | "failure"
+//   project_path — absolute path of origin project
+//   stale        — true if unused for 30+ days (set by decay check)
+// =============================================================================
+
+'use strict';
+
+const fs     = require('fs');
+const os     = require('os');
+const path   = require('path');
+const crypto = require('crypto');
+
+const MEMORY_DIR = process.env.KODELYTH_MEMORY_DIR
+  || path.join(os.homedir(), '.kodelyth', 'memory');
+
+const INSTINCTS_FILE = path.join(MEMORY_DIR, 'instincts.jsonl');
+const STALE_DAYS     = 30;
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+function ensureDir() {
+  if (!fs.existsSync(MEMORY_DIR)) fs.mkdirSync(MEMORY_DIR, { recursive: true });
+}
+
+function slugify(text) {
+  return String(text || '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 60) || 'rule';
+}
+
+function deterministicId(rule, projectPath) {
+  return crypto
+    .createHash('sha256')
+    .update(`${rule}::${projectPath || ''}`)
+    .digest('hex')
+    .slice(0, 12);
+}
+
+function extractTriggers(ruleText) {
+  // Heuristic: extract key words that would activate this rule
+  const FILLER = new Set(['use','don\'t','never','always','please','stop','avoid',
+    'instead','of','not','the','a','an','and','or','in','on','at','to','is',
+    'are','was','were','do','does','did','should','would','could']);
+  return ruleText
+    .toLowerCase()
+    .replace(/[^a-z0-9\s]/g, ' ')
+    .split(/\s+/)
+    .filter(w => w.length >= 3 && !FILLER.has(w))
+    .slice(0, 6);
+}
+
+function today() {
+  return new Date().toISOString().split('T')[0];
+}
+
+function daysSince(isoDate) {
+  if (!isoDate) return 999;
+  return Math.floor((Date.now() - new Date(isoDate).getTime()) / 86400000);
+}
+
+// ── Read / Write ──────────────────────────────────────────────────────────────
+
+function loadAll() {
+  if (!fs.existsSync(INSTINCTS_FILE)) return [];
+  return fs.readFileSync(INSTINCTS_FILE, 'utf8')
+    .split('\n')
+    .filter(Boolean)
+    .map(line => { try { return JSON.parse(line); } catch { return null; } })
+    .filter(Boolean);
+}
+
+function saveAll(instincts) {
+  ensureDir();
+  fs.writeFileSync(
+    INSTINCTS_FILE,
+    instincts.map(i => JSON.stringify(i)).join('\n') + '\n',
+    'utf8'
+  );
+}
+
+// ── Public API ────────────────────────────────────────────────────────────────
+
+/**
+ * Add a new instinct from a correction string.
+ * If a record with the same id already exists, increments use_count.
+ * Returns the instinct record.
+ */
+function captureFromCorrection(ruleText, projectPath, scope = 'project') {
+  ensureDir();
+  const id = deterministicId(ruleText, projectPath);
+  const all = loadAll();
+
+  const existing = all.find(i => i.id === id);
+  if (existing) {
+    existing.use_count = (existing.use_count || 1) + 1;
+    existing.last_used = today();
+    existing.confidence = Math.min(1.0, (existing.confidence || 0.7) + 0.1);
+    existing.stale = false;
+    saveAll(all);
+    return existing;
+  }
+
+  const instinct = {
+    id,
+    pattern: slugify(ruleText),
+    rule: ruleText.trim(),
+    scope,
+    trigger: extractTriggers(ruleText),
+    confidence: 0.7,
+    source: 'correction',
+    created: today(),
+    last_used: today(),
+    use_count: 1,
+    outcome: null,
+    project_path: projectPath || null,
+    stale: false,
+  };
+
+  fs.appendFileSync(INSTINCTS_FILE, JSON.stringify(instinct) + '\n', 'utf8');
+  return instinct;
+}
+
+/**
+ * Record the outcome of an instinct (success/failure) by id.
+ * A failure reduces confidence; a success boosts it.
+ */
+function recordOutcome(id, outcome) {
+  const all = loadAll();
+  const instinct = all.find(i => i.id === id);
+  if (!instinct) return null;
+
+  instinct.outcome = outcome;
+  instinct.last_used = today();
+
+  if (outcome === 'success') {
+    instinct.confidence = Math.min(1.0, (instinct.confidence || 0.7) + 0.15);
+  } else if (outcome === 'failure') {
+    instinct.confidence = Math.max(0.0, (instinct.confidence || 0.7) - 0.3);
+  }
+
+  saveAll(all);
+  return instinct;
+}
+
+/**
+ * Decay check (Improvement D).
+ * Marks instincts unused for STALE_DAYS+ as stale: true.
+ * Returns list of newly-stale instincts for review prompting.
+ */
+function runDecayCheck() {
+  const all = loadAll();
+  const newlyStale = [];
+
+  for (const instinct of all) {
+    const age = daysSince(instinct.last_used);
+    const wasStale = instinct.stale;
+    instinct.stale = age >= STALE_DAYS;
+    if (instinct.stale && !wasStale) {
+      newlyStale.push(instinct);
+    }
+  }
+
+  if (newlyStale.length > 0) saveAll(all);
+  return newlyStale;
+}
+
+/**
+ * Return all instincts, optionally filtered.
+ * Filters: { scope, stale, minConfidence, projectPath }
+ */
+function list({ scope, stale, minConfidence, projectPath } = {}) {
+  let all = loadAll();
+  if (scope !== undefined)          all = all.filter(i => i.scope === scope);
+  if (stale !== undefined)          all = all.filter(i => Boolean(i.stale) === stale);
+  if (minConfidence !== undefined)  all = all.filter(i => (i.confidence || 0) >= minConfidence);
+  if (projectPath !== undefined)    all = all.filter(i => i.project_path === projectPath);
+  return all;
+}
+
+/**
+ * Prune instincts with confidence below threshold (auto-cleanup of bad patterns).
+ */
+function pruneWeak(threshold = 0.2) {
+  const all = loadAll();
+  const kept = all.filter(i => (i.confidence || 0.7) >= threshold);
+  const pruned = all.length - kept.length;
+  if (pruned > 0) saveAll(kept);
+  return pruned;
+}
+
+/**
+ * Improvement C: outcome tracking via store.js bridge.
+ *
+ * Called when a follow-up file edit implies a previous instinct didn't stick.
+ * Finds instincts that match both the project_path AND a fragment of the
+ * problem text, then records a failure outcome on each match.
+ *
+ * This is intentionally fuzzy: a partial match (>20% token overlap between
+ * problemHint and instinct.rule) is enough to trigger a downgrade. The goal
+ * is to surface bad patterns, not to be surgically precise.
+ *
+ * Returns the list of downgraded instinct ids.
+ */
+function recordOutcomeByProject(projectPath, problemHint, outcome) {
+  if (!projectPath && !problemHint) return [];
+  const all = loadAll();
+  const changed = [];
+
+  const hintTokens = problemHint
+    ? new Set(
+        String(problemHint)
+          .toLowerCase()
+          .replace(/[^a-z0-9\s]/g, ' ')
+          .split(/\s+/)
+          .filter(t => t.length >= 3)
+      )
+    : null;
+
+  for (const instinct of all) {
+    // Project match (when provided)
+    if (projectPath && instinct.project_path && instinct.project_path !== projectPath) continue;
+
+    // Problem text fuzzy match (when provided)
+    if (hintTokens && hintTokens.size > 0) {
+      const ruleTokens = String(instinct.rule || '')
+        .toLowerCase()
+        .replace(/[^a-z0-9\s]/g, ' ')
+        .split(/\s+/)
+        .filter(t => t.length >= 3);
+      const overlap = ruleTokens.filter(t => hintTokens.has(t)).length;
+      const ratio   = overlap / Math.max(hintTokens.size, 1);
+      if (ratio < 0.2) continue; // < 20% overlap — not a match
+    }
+
+    instinct.outcome   = outcome;
+    instinct.last_used = today();
+    if (outcome === 'success') {
+      instinct.confidence = Math.min(1.0, (instinct.confidence || 0.7) + 0.15);
+    } else if (outcome === false || outcome === 'failure') {
+      instinct.confidence = Math.max(0.0, (instinct.confidence || 0.7) - 0.3);
+    }
+    changed.push(instinct.id);
+  }
+
+  if (changed.length > 0) saveAll(all);
+  return changed;
+}
+
+module.exports = {
+  captureFromCorrection,
+  recordOutcome,
+  recordOutcomeByProject,
+  runDecayCheck,
+  list,
+  pruneWeak,
+  INSTINCTS_FILE,
+  STALE_DAYS,
+};

package/scripts/memory/store.js

@@ -257,6 +257,106 @@ function forget(memoryId) {
   return found;
 }
 
+// ── Improvement C: outcome tracking ──────────────────────────────────────────
+// Mark a memory as resolved:true (success) or resolved:false (failure).
+// Called automatically by the PostToolUse hook when an edited file matches
+// a memory's files[] list — a follow-up fix implies the previous approach
+// didn't fully work, so resolved=false. The user can also call this manually.
+//
+// Side-effect: also propagates to instincts.js if the instinct module exists,
+// so low-confidence instincts sourced from the same session get downgraded.
+function resolveMemory(memoryId, resolved) {
+  if (!fs.existsSync(PATHS.log)) return false;
+  const lines = fs.readFileSync(PATHS.log, 'utf8').split('\n').filter(Boolean);
+  let found = false;
+  const updated = lines.map(line => {
+    try {
+      const m = JSON.parse(line);
+      if (m.id === memoryId && !m.deleted) {
+        found = true;
+        return JSON.stringify({
+          ...m,
+          resolved,
+          resolved_at: new Date().toISOString(),
+        });
+      }
+      return line;
+    } catch {
+      return line;
+    }
+  });
+  if (found) {
+    fs.writeFileSync(PATHS.log, updated.join('\n') + '\n');
+  }
+  return found;
+}
+
+// Find unresolved memories whose files[] overlap with the given file path.
+// Returns [ { id, problem, files, captured_at } ] — caller decides what to do.
+function findMemoriesForFile(filePath, options = {}) {
+  const { projectRoot = null, limit = 5 } = options;
+  if (!fs.existsSync(PATHS.log)) return [];
+
+  const normFile = path.normalize(filePath);
+  const lines    = fs.readFileSync(PATHS.log, 'utf8').split('\n').filter(Boolean);
+  const matches  = [];
+
+  for (const line of lines) {
+    let m;
+    try { m = JSON.parse(line); } catch { continue; }
+    if (m.deleted || m.resolved !== undefined) continue; // skip already resolved
+    if (!Array.isArray(m.files) || m.files.length === 0) continue;
+    if (projectRoot && m.project_path && m.project_path !== projectRoot) continue;
+
+    const hit = m.files.some(f => {
+      const normF = path.normalize(String(f));
+      return normF === normFile || normFile.endsWith(normF) || normF.endsWith(normFile);
+    });
+
+    if (hit) {
+      matches.push({
+        id:          m.id,
+        problem:     m.problem,
+        approach:    m.approach,
+        files:       m.files,
+        captured_at: m.captured_at,
+        project_path: m.project_path,
+      });
+      if (matches.length >= limit) break;
+    }
+  }
+
+  return matches;
+}
+
+// Auto-resolve hook: called by PostToolUse (Write|Edit) with the file just edited.
+// Marks any unresolved memory that listed this file as resolved:false, then
+// nudges the instinct schema to downgrade the matching instinct's confidence.
+function autoResolveOnEdit(filePath, projectRoot = null) {
+  const affected = findMemoriesForFile(filePath, { projectRoot });
+  if (affected.length === 0) return [];
+
+  const resolved = [];
+  for (const m of affected) {
+    const ok = resolveMemory(m.id, false);
+    if (ok) resolved.push(m);
+  }
+
+  // Propagate to instinct schema — best-effort only
+  try {
+    const instinctsPath = path.join(__dirname, 'instincts.js');
+    if (fs.existsSync(instinctsPath)) {
+      const instincts = require(instinctsPath);
+      for (const m of resolved) {
+        // Match by project_path + approximate problem text
+        instincts.recordOutcomeByProject(m.project_path, m.problem, false);
+      }
+    }
+  } catch { /* never block */ }
+
+  return resolved;
+}
+
 function rebuildIndex() {
   const memories = readMemories();
   let index = { tokens: {}, docCount: 0, avgDocLength: 0, totalLength: 0 };
@@ -297,4 +397,8 @@ module.exports = {
   stats,
   tokenise,
   projectHash,
+  // Improvement C
+  resolveMemory,
+  findMemoriesForFile,
+  autoResolveOnEdit,
 };