lynkr 9.9.0 → 9.10.0

package/src/routing/intent-score.js

@@ -47,14 +47,15 @@ const ANCHORS_PATHS = [
 ];
 const VECTORS_CACHE_PATH = path.join(__dirname, '../../data/difficulty-anchors.vectors.json');
 
-// Class → representative score. Chosen so each class lands inside an
-// existing default band (SIMPLE 0-25, MEDIUM 26-50, COMPLEX 51-75) and the
-// blend can NEVER reach REASONING (76+). Calibration may later collapse
-// bands into degenerate ranges without touching these.
+// Class → representative score. Chosen so each class lands inside a tier
+// band and routing boundaries are tunable via tier edges (model-tiers.js).
+// Config B (local → GLM → Claude): substantive=MEDIUM/ollama,
+// heavyweight=COMPLEX/GLM, frontier=REASONING/Claude.
 const CLASS_VALUES = {
   trivial: 10,
   substantive: 45,
   heavyweight: 68,
+  frontier: 85,
 };
 
 // Softmax temperature over cosine sims. Real inter-class sim gaps on
@@ -77,8 +78,16 @@ const CLASS_BANDS = {
   trivial: [0, 25],
   substantive: [26, 50],
   heavyweight: [51, 75],
+  frontier: [76, 100],
 };
 
+// Frontier class (REASONING tier) requires minimum similarity — a weak
+// topical match can't jump to the expensive tier. Tuned on the validation
+// set (scripts/validate-intent-anchors.js). Below this floor, frontier is
+// excluded from the blend entirely and scoring behaves like the 3-class
+// baseline. Hardcoded constant (no env var per user directive).
+const FRONTIER_MIN_SIM = 0.50;
+
 function intentScoreMode() {
   const m = (process.env.LYNKR_INTENT_SCORE_MODE || 'anchor').toLowerCase();
   return m === 'legacy' ? 'legacy' : 'anchor';
@@ -191,21 +200,32 @@ function classify(embedding, centroids) {
 }
 
 /**
- * Softmax-blend class sims into a continuous score. Bounded by construction
- * to [min(CLASS_VALUES), max(CLASS_VALUES)] — REASONING stays unreachable.
+ * Softmax-blend class sims into a continuous score. Frontier class requires
+ * minimum similarity (FRONTIER_MIN_SIM) to participate — below the floor,
+ * it's excluded from the blend and scoring behaves like the 3-class baseline.
+ * Lexical fallback path stays clamped ≤75 (see _lexicalCleanScore).
  */
 function blendScore(sims) {
   const classes = Object.keys(CLASS_VALUES);
-  const max = Math.max(...classes.map((c) => sims[c] ?? -1));
+  // Frontier similarity floor: a weak topical match can't jump tiers.
+  const frontierSim = sims.frontier ?? -1;
+  const activeSims = { ...sims };
+  if (frontierSim < FRONTIER_MIN_SIM) {
+    delete activeSims.frontier; // excluded from blend
+  }
+  const activeClasses = Object.keys(CLASS_VALUES).filter(c => c in activeSims);
+  if (activeClasses.length === 0) return CLASS_VALUES.substantive; // degenerate
+
+  const max = Math.max(...activeClasses.map((c) => activeSims[c] ?? -1));
   let totalW = 0;
   let total = 0;
-  for (const cls of classes) {
-    const w = Math.exp(((sims[cls] ?? -1) - max) / BLEND_TEMPERATURE);
+  for (const cls of activeClasses) {
+    const w = Math.exp(((activeSims[cls] ?? -1) - max) / BLEND_TEMPERATURE);
     totalW += w;
     total += w * CLASS_VALUES[cls];
   }
   const score = totalW > 0 ? total / totalW : CLASS_VALUES.substantive;
-  return Math.round(Math.max(0, Math.min(75, score)));
+  return Math.round(Math.max(0, Math.min(100, score)));
 }
 
 // --- default centroids (lazy singleton, disk-cached) ------------------------
@@ -294,6 +314,58 @@ function _lexicalCleanScore(text) {
  * @returns {Promise<{score:number, mode:'anchor'|'lexical', class?:string, sims?:object, text:string}|null>}
  *   null → caller keeps its legacy score (legacy mode, or nothing to score)
  */
+// Reconcile anchor's implied tier with the LLM classifier's tier.
+// - Agreement → keep anchor score as-is.
+// - Classifier lower than anchor → trust classifier (catches embedding
+//   false-positives like "list exports" scoring REASONING). Position
+//   score at midpoint of classifier's target band.
+// - Classifier higher than anchor → safety-gate: require confidence≥0.8
+//   before trusting an escalation to a more expensive tier. Below that,
+//   keep the cheaper anchor decision.
+function _reconcile(anchorScore, anchorClass, classifierResult) {
+  if (!classifierResult) return { score: anchorScore, reconciled: false };
+  if (classifierResult.confidence < 0.6) return { score: anchorScore, reconciled: false };
+
+  // Anchor class → implied tier (matches model-tiers.js band definitions).
+  const anchorTier = anchorScore <= 19 ? 'SIMPLE'
+    : anchorScore <= 50 ? 'MEDIUM'
+    : anchorScore <= 75 ? 'COMPLEX'
+    : 'REASONING';
+  const classifierTier = classifierResult.tier;
+
+  if (anchorTier === classifierTier) return { score: anchorScore, reconciled: false };
+
+  const TIER_ORDER = ['SIMPLE', 'MEDIUM', 'COMPLEX', 'REASONING'];
+  const anchorIdx = TIER_ORDER.indexOf(anchorTier);
+  const classifierIdx = TIER_ORDER.indexOf(classifierTier);
+
+  // Midpoints of each tier band (from model-tiers.js defaults):
+  //   SIMPLE 0-19 → 10, MEDIUM 20-50 → 35, COMPLEX 51-75 → 63, REASONING 76-100 → 88
+  const TIER_MIDPOINT = { SIMPLE: 10, MEDIUM: 35, COMPLEX: 63, REASONING: 88 };
+
+  if (classifierIdx < anchorIdx) {
+    // Classifier says LOWER tier — trust it. Fixes over-routing.
+    return { score: TIER_MIDPOINT[classifierTier], reconciled: 'down' };
+  }
+  // Classifier says HIGHER tier — gate on confidence, and cap the jump at
+  // ONE band above the anchor. The classifier is a tiebreaker, not an
+  // oracle: qwen2.5:3b's confidence is degenerate (92% of eval answers say
+  // 0.9-1.0, incl. every wrong one), so an unbounded jump let a 3B verdict
+  // catapult "Who kills him ?" from anchor 25 to 88 → REASONING →
+  // subscription passthrough (live incident 2026-07-21). Escalating past
+  // the adjacent band now takes consecutive turns that keep re-scoring
+  // higher, which is exactly the persistence a genuinely hard conversation
+  // exhibits.
+  if (classifierResult.confidence >= 0.8) {
+    const cappedIdx = Math.min(classifierIdx, anchorIdx + 1);
+    return {
+      score: TIER_MIDPOINT[TIER_ORDER[cappedIdx]],
+      reconciled: cappedIdx < classifierIdx ? 'up_capped' : 'up',
+    };
+  }
+  return { score: anchorScore, reconciled: 'up_gated' };
+}
+
 async function scoreIntent(payload, opts = {}) {
   const mode = opts.mode ?? intentScoreMode();
   if (mode === 'legacy') return null;
@@ -314,8 +386,52 @@ async function scoreIntent(payload, opts = {}) {
       if (Array.isArray(embedding) && embedding.length > 0) {
         const { cls, sims } = classify(embedding, centroids);
         const [lo, hi] = CLASS_BANDS[cls];
-        const score = Math.max(lo, Math.min(hi, blendScore(sims)));
-        return { score, mode: 'anchor', class: cls, sims, text };
+        const anchorScore = Math.max(lo, Math.min(hi, blendScore(sims)));
+
+        // LLM classifier — second opinion. Skipped in tests (opts.skipClassifier)
+        // to keep unit tests hermetic. Runs live otherwise.
+        let classifierResult = null;
+        if (!opts.skipClassifier) {
+          try {
+            const { classifyDifficulty } = require('./difficulty-classifier');
+            classifierResult = await classifyDifficulty(text, {
+              forceMatched: opts.forceMatched,
+              riskLevel: opts.riskLevel,
+              // Condensed prior turns, threaded by the router's window loop.
+              // Without it a short follow-up ("Who kills him ?") is
+              // unclassifiable in isolation.
+              context: typeof payload?._conversationContext === 'string'
+                ? payload._conversationContext
+                : null,
+            });
+          } catch (err) {
+            logger.debug({ err: err.message }, '[IntentScore] classifier failed — anchor only');
+          }
+        }
+
+        const { score, reconciled } = _reconcile(anchorScore, cls, classifierResult);
+        if (reconciled) {
+          logger.debug({
+            text: text.slice(0, 80),
+            anchorScore,
+            anchorClass: cls,
+            classifierTier: classifierResult?.tier,
+            classifierConfidence: classifierResult?.confidence,
+            reconciled,
+            finalScore: score,
+          }, '[IntentScore] classifier reconciled anchor score');
+        }
+        return {
+          score,
+          mode: reconciled ? 'anchor+classifier' : 'anchor',
+          class: cls,
+          sims,
+          text,
+          anchorScore,
+          classifierTier: classifierResult?.tier ?? null,
+          classifierConfidence: classifierResult?.confidence ?? null,
+          reconciled,
+        };
       }
     }
   } catch (err) {
@@ -327,6 +443,8 @@ async function scoreIntent(payload, opts = {}) {
 
 module.exports = {
   CLASS_VALUES,
+  CLASS_BANDS,
+  FRONTIER_MIN_SIM,
   intentScoreMode,
   extractCleanUserText,
   cosine,
@@ -336,4 +454,6 @@ module.exports = {
   scoreIntent,
   // exposed for the replay script
   getDefaultCentroids,
+  // exposed for tests
+  _reconcile,
 };

package/src/routing/session-affinity.js

@@ -114,12 +114,18 @@ function getPin(sessionId) {
  * Accepts a routing decision plus session-scoped stats used by the re-pin
  * heuristics.
  *
+ * `hasToolHistory` is sticky-true: once set to true it stays true for the
+ * pin's lifetime — a follow-up refresh that didn't carry tool blocks (e.g.
+ * a plain-text turn between tool exchanges) must not clear the flag, or the
+ * Signal-2 side-channel check would flip open again.
+ *
  * @param {string} sessionId
  * @param {{provider:string, model?:string|null, tier?:string|null}} decision
- * @param {{messageCount?:number|null, promptTokensEst?:number|null}} [stats]
+ * @param {{messageCount?:number|null, promptTokensEst?:number|null, hasToolHistory?:boolean}} [stats]
  */
 function setPin(sessionId, decision, stats = {}) {
   if (!sessionId || !decision?.provider) return;
+  const prev = pins.get(sessionId);
   const pin = {
     provider: decision.provider,
     model: decision.model ?? null,
@@ -127,6 +133,7 @@ function setPin(sessionId, decision, stats = {}) {
     score: typeof decision.score === 'number' ? decision.score : null,
     messageCount: stats.messageCount ?? null,
     promptTokensEst: stats.promptTokensEst ?? null,
+    hasToolHistory: !!(stats.hasToolHistory || prev?.hasToolHistory),
     ts: Date.now(),
   };
   // Refresh insertion order so active sessions aren't evicted.

package/src/routing/side-channel-detector.js

@@ -0,0 +1,103 @@
+/**
+ * Side-Channel Detector — first-user-message fingerprint drift
+ *
+ * Complements the pin-based side-channel signals in router.js:
+ *   1. Message-count regression   → needs pin
+ *   2. Tool-history mismatch      → needs pin with hasToolHistory
+ *   3. First-message fingerprint  → THIS module — works before any pin exists
+ *
+ * Purpose: on a session's first request, cache a fingerprint of messages[0].
+ * On later requests within the TTL, if messages[0] no longer matches, the
+ * payload has been replayed by a background utility caller (Claude Code
+ * wraps the original user text in `<session>...</session>` for title-gen,
+ * substitutes recap prompts, etc.).
+ *
+ * Trade-off: if a background call fires BEFORE the first real user turn
+ * lands, its wrapper prompt becomes the anchor. That's rare in practice —
+ * observed order in real traffic is user turn first, background call after.
+ * If it does happen, the real user's next request will be mislabelled once,
+ * then the anchor will "settle" once ttl expires.
+ *
+ * @module routing/side-channel-detector
+ */
+
+const crypto = require('crypto');
+const logger = require('../logger');
+
+const TTL_MS = 30 * 60 * 1000;   // 30 min — matches an interactive Claude Code session
+const MAX_ENTRIES = 2000;         // LRU cap (same order of magnitude as session-affinity)
+
+/** @type {Map<string, {hash:string, ts:number}>} */
+const anchors = new Map();
+
+function _evictIfNeeded() {
+  if (anchors.size <= MAX_ENTRIES) return;
+  const oldest = anchors.keys().next().value;
+  if (oldest !== undefined) anchors.delete(oldest);
+}
+
+function _firstUserText(messages) {
+  if (!Array.isArray(messages)) return null;
+  for (const m of messages) {
+    if (m?.role !== 'user') continue;
+    if (typeof m.content === 'string') return m.content;
+    if (Array.isArray(m.content)) {
+      const t = m.content.filter(b => b?.type === 'text').map(b => b.text || '').join('');
+      if (t) return t;
+    }
+  }
+  return null;
+}
+
+function _hash(str) {
+  return crypto.createHash('sha1').update(str).digest('hex').slice(0, 16);
+}
+
+/**
+ * Check whether the payload's first user message drifts from the cached
+ * anchor for this session. Returns true only when we have an anchor AND
+ * it disagrees; returns false when no anchor exists yet (bootstrap case)
+ * and stores this payload's hash as the new anchor.
+ *
+ * @param {string|null} sessionId
+ * @param {Array} messages
+ * @returns {boolean} true if drift detected (caller should treat as side channel)
+ */
+function check(sessionId, messages) {
+  if (!sessionId) return false;
+  const text = _firstUserText(messages);
+  if (!text) return false;
+  const hash = _hash(text);
+  const now = Date.now();
+
+  const cached = anchors.get(sessionId);
+  if (cached) {
+    // Refresh insertion order for LRU
+    anchors.delete(sessionId);
+    if (now - cached.ts > TTL_MS) {
+      // Expired — reset the anchor, no drift claim.
+      anchors.set(sessionId, { hash, ts: now });
+      _evictIfNeeded();
+      return false;
+    }
+    anchors.set(sessionId, cached);
+    if (cached.hash !== hash) {
+      logger.debug({ sessionId, cachedHash: cached.hash, newHash: hash },
+        '[SideChannel] First-message fingerprint drift');
+      return true;
+    }
+    return false;
+  }
+
+  // Bootstrap — first sighting of this session, store and pass.
+  anchors.set(sessionId, { hash, ts: now });
+  _evictIfNeeded();
+  return false;
+}
+
+/** Test/maintenance helper — clear the in-memory anchors. */
+function _clear() {
+  anchors.clear();
+}
+
+module.exports = { check, _clear };

package/src/server.js

@@ -18,52 +18,13 @@ const { getCircuitBreakerRegistry } = require("./clients/circuit-breaker");
 const metrics = require("./metrics");
 const logger = require("./logger");
 const { initialiseMcp } = require("./mcp");
-const { registerStubTools } = require("./tools/stubs");
-const { registerWorkspaceTools } = require("./tools/workspace");
-const { registerExecutionTools } = require("./tools/execution");
-const { registerWebTools } = require("./tools/web");
-const { registerIndexerTools } = require("./tools/indexer");
-const { registerEditTools } = require("./tools/edits");
-const { registerGitTools } = require("./tools/git");
-const { registerTaskTools } = require("./tools/tasks");
-const { registerTestTools } = require("./tools/tests");
-const { registerMcpTools } = require("./tools/mcp");
-const { registerAgentTaskTool } = require("./tools/agent-task");
-const { registerDecomposeTool } = require("./tools/decompose");
 const { initConfigWatcher, getConfigWatcher } = require("./config/watcher");
 const { initializeHeadroom, shutdownHeadroom, getHeadroomManager } = require("./headroom");
 const { getWorkerPool, isWorkerPoolReady } = require("./workers/pool");
-const lazyLoader = require("./tools/lazy-loader");
-const { setLazyLoader } = require("./tools");
 const { waitForOllama } = require("./clients/ollama-startup");
 
 initialiseMcp();
 
-setLazyLoader(lazyLoader);
-
-const LAZY_TOOLS_ENABLED = process.env.LAZY_TOOLS_ENABLED !== "false";
-
-if (LAZY_TOOLS_ENABLED) {
-  // Only load core tools at startup (stubs, workspace, execution)
-  lazyLoader.loadCoreTools();
-  logger.info({ mode: "lazy" }, "Lazy tool loading enabled - other tools will load on demand");
-} else {
-  // Backwards compatibility: load all tools at startup
-  registerStubTools();
-  registerWorkspaceTools();
-  registerExecutionTools();
-  registerWebTools();
-  registerIndexerTools();
-  registerEditTools();
-  registerGitTools();
-  registerTaskTools();
-  registerTestTools();
-  registerMcpTools();
-  registerAgentTaskTool();
-  registerDecomposeTool();
-  logger.info({ mode: "eager" }, "All tools loaded at startup");
-}
-
 function createApp() {
   const app = express();
   const path = require('path');
@@ -171,13 +132,6 @@ function createApp() {
     res.json({ enabled: true, ...cache.getStats() });
   });
 
-  app.get("/metrics/lazy-tools", (req, res) => {
-    res.json({
-      enabled: LAZY_TOOLS_ENABLED,
-      ...lazyLoader.getLoaderStats(),
-    });
-  });
-
   app.use(router);
 
   app.use('/dashboard', require('./dashboard/router'));
@@ -246,6 +200,26 @@ async function start() {
     console.log(`Claude→Databricks proxy listening on http://localhost:${config.port}`);
   });
 
+  // Classifier bootstrap check — non-blocking, log-only.
+  // Detects ollama + confirms the classifier model is pulled. Never auto-
+  // installs (that's `lynkr init`'s job); warns and lets scoring fall back
+  // to anchor-only if either is missing.
+  (async () => {
+    try {
+      const { ensureClassifierReady } = require('./routing/classifier-setup');
+      const result = await ensureClassifierReady({
+        mode: 'boot',
+        log: (m) => logger.info(m),
+        warn: (m) => logger.warn(m),
+      });
+      if (result.ready) {
+        logger.info({ classifier: 'ready', warmed: result.warmed }, '[classifier-setup] Difficulty classifier ready');
+      }
+    } catch (err) {
+      logger.debug({ err: err.message }, '[classifier-setup] bootstrap check failed (classifier will fall back)');
+    }
+  })();
+
   // Start session cleanup manager. It also drives routing-side maintenance
   // (telemetry retention + session-pin TTL) via its runCleanup tick — see
   // src/sessions/cleanup.js.

package/src/agents/context-manager.js

@@ -1,236 +0,0 @@
-const fs = require("fs");
-const path = require("path");
-const logger = require("../logger");
-
-class ContextManager {
-  constructor() {
-    this.transcriptsDir = path.join(process.cwd(), "data", "agent-transcripts");
-    this.ensureTranscriptsDir();
-  }
-
-  ensureTranscriptsDir() {
-    if (!fs.existsSync(this.transcriptsDir)) {
-      fs.mkdirSync(this.transcriptsDir, { recursive: true });
-    }
-  }
-
-  /**
-   * Create fresh context for subagent
-   * @param {Object} agentDef - Agent definition
-   * @param {string} taskPrompt - Task from main agent
-   * @param {Object} mainContext - Minimal context from main agent
-   * @returns {Object} - Fresh context for subagent
-   */
-  createSubagentContext(agentDef, taskPrompt, mainContext = {}) {
-    const agentId = this.generateAgentId();
-    const transcriptPath = path.join(this.transcriptsDir, `agent-${agentId}.jsonl`);
-
-    // Initialize transcript file
-    fs.writeFileSync(transcriptPath, "");
-
-    // Build minimal context (NOT full main agent history)
-    const messages = [];
-
-    // System prompt from agent definition
-    messages.push({
-      role: "system",
-      content: agentDef.systemPrompt
-    });
-
-    // Optional: Add minimal context from main agent
-    if (mainContext.relevant_context) {
-      messages.push({
-        role: "system",
-        content: `Context from main agent:\n${mainContext.relevant_context}`
-      });
-    }
-
-    // Task prompt
-    messages.push({
-      role: "user",
-      content: taskPrompt
-    });
-
-    const context = {
-      agentId,
-      agentName: agentDef.name,
-      transcriptPath,
-      messages,
-      steps: 0,
-      maxSteps: agentDef.maxSteps,
-      model: agentDef.model,
-      allowedTools: agentDef.allowedTools,
-      startTime: Date.now(),
-
-      // Original task prompt — consumed by the Reflector to infer task type.
-      taskPrompt,
-
-      // In-memory transcript mirror of the JSONL file — consumed by the
-      // Reflector for tool-usage / error-recovery analysis. The JSONL file
-      // remains the durable record; this array is the hot-path copy.
-      transcript: [],
-
-      // Token tracking
-      inputTokens: 0,
-      outputTokens: 0,
-
-      // State
-      terminated: false,
-      result: null
-    };
-
-    this.writeTranscriptEntry(transcriptPath, {
-      type: "agent_start",
-      agentId,
-      agentName: agentDef.name,
-      taskPrompt,
-      timestamp: Date.now()
-    });
-
-    logger.info({ agentId, agentName: agentDef.name }, "Created fresh subagent context");
-
-    return context;
-  }
-
-  /**
-   * Add message to subagent context
-   */
-  addMessage(context, message) {
-    context.messages.push(message);
-
-    this.writeTranscriptEntry(context.transcriptPath, {
-      type: "message",
-      agentId: context.agentId,
-      message,
-      timestamp: Date.now()
-    });
-  }
-
-  /**
-   * Record tool execution in transcript
-   */
-  recordToolCall(context, toolName, input, output, error = null) {
-    const entry = {
-      type: "tool_call",
-      agentId: context.agentId,
-      step: context.steps,
-      toolName,
-      input,
-      output: error ? null : output,
-      error: error ? error.message : null,
-      timestamp: Date.now()
-    };
-
-    // Keep the in-memory transcript in sync so the Reflector (which reads
-    // context.transcript) sees tool calls without re-parsing the JSONL file.
-    if (Array.isArray(context.transcript)) {
-      context.transcript.push(entry);
-    }
-
-    this.writeTranscriptEntry(context.transcriptPath, entry);
-  }
-
-  /**
-   * Complete subagent execution
-   */
-  completeExecution(context, result) {
-    context.terminated = true;
-    context.result = result;
-
-    this.writeTranscriptEntry(context.transcriptPath, {
-      type: "agent_complete",
-      agentId: context.agentId,
-      result,
-      stats: {
-        steps: context.steps,
-        durationMs: Date.now() - context.startTime,
-        inputTokens: context.inputTokens,
-        outputTokens: context.outputTokens
-      },
-      timestamp: Date.now()
-    });
-
-    logger.info({
-      agentId: context.agentId,
-      steps: context.steps,
-      durationMs: Date.now() - context.startTime
-    }, "Subagent execution completed");
-  }
-
-  /**
-   * Fail subagent execution
-   */
-  failExecution(context, error) {
-    context.terminated = true;
-
-    this.writeTranscriptEntry(context.transcriptPath, {
-      type: "agent_failed",
-      agentId: context.agentId,
-      error: error.message,
-      stats: {
-        steps: context.steps,
-        durationMs: Date.now() - context.startTime
-      },
-      timestamp: Date.now()
-    });
-
-    logger.error({
-      agentId: context.agentId,
-      error: error.message
-    }, "Subagent execution failed");
-  }
-
-  /**
-   * Write entry to transcript file (JSONL format)
-   */
-  writeTranscriptEntry(transcriptPath, entry) {
-    try {
-      fs.appendFileSync(transcriptPath, JSON.stringify(entry) + "\n");
-    } catch (error) {
-      logger.warn({ error: error.message }, "Failed to write transcript entry");
-    }
-  }
-
-  /**
-   * Read transcript for debugging
-   */
-  readTranscript(agentId) {
-    const transcriptPath = path.join(this.transcriptsDir, `agent-${agentId}.jsonl`);
-
-    if (!fs.existsSync(transcriptPath)) {
-      return null;
-    }
-
-    const lines = fs.readFileSync(transcriptPath, "utf8").split("\n").filter(l => l.trim());
-    return lines.map(line => JSON.parse(line));
-  }
-
-  /**
-   * Generate unique agent ID
-   */
-  generateAgentId() {
-    return `${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
-  }
-
-  /**
-   * Clean old transcripts (older than 7 days)
-   */
-  cleanOldTranscripts() {
-    const maxAge = 7 * 24 * 60 * 60 * 1000; // 7 days
-    const now = Date.now();
-
-    const files = fs.readdirSync(this.transcriptsDir);
-
-    for (const file of files) {
-      const filePath = path.join(this.transcriptsDir, file);
-      const stats = fs.statSync(filePath);
-
-      if (now - stats.mtimeMs > maxAge) {
-        fs.unlinkSync(filePath);
-        logger.debug({ file }, "Cleaned old transcript");
-      }
-    }
-  }
-}
-
-module.exports = ContextManager;