driftguard-mcp 0.1.0

package/dist/bin.js

@@ -0,0 +1,2205 @@
+#!/usr/bin/env node
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/watchers/claude-parser.ts
+function parseTimestamp(raw) {
+  if (typeof raw === "number" && isFinite(raw)) return raw;
+  if (typeof raw === "string") {
+    const ms = new Date(raw).getTime();
+    if (isFinite(ms)) return ms;
+  }
+  return Date.now();
+}
+function parseJSONL(filePath) {
+  const raw = fs.readFileSync(filePath, "utf-8");
+  const lines = raw.split("\n").filter((l) => l.trim());
+  const messages = [];
+  let skipped = 0;
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+      if (entry.type !== "user" && entry.type !== "assistant") continue;
+      const content = entry.message?.content;
+      let text = "";
+      if (typeof content === "string") {
+        text = content.trim();
+      } else if (Array.isArray(content)) {
+        text = content.filter((block) => block.type === "text" && typeof block.text === "string").map((block) => block.text.trim()).join("\n").trim();
+      }
+      if (!text.trim()) continue;
+      messages.push({
+        id: entry.uuid,
+        role: entry.message.role,
+        content: text,
+        timestamp: parseTimestamp(entry.timestamp)
+      });
+    } catch {
+      skipped++;
+    }
+  }
+  if (skipped > 0) {
+    const pct = Math.round(skipped / lines.length * 100);
+    console.warn(`[driftcli] Skipped ${skipped}/${lines.length} malformed JSONL lines (${pct}%) in ${path.basename(filePath)}`);
+  }
+  return messages;
+}
+function claudeProjectsDir() {
+  return path.join(process.env.DRIFTCLI_HOME ?? os.homedir(), ".claude", "projects");
+}
+function findSessionByUUID(sessionId) {
+  const baseDir = claudeProjectsDir();
+  if (!fs.existsSync(baseDir)) return null;
+  let dirs = [];
+  try {
+    dirs = fs.readdirSync(baseDir).map((d) => path.join(baseDir, d)).filter((d) => {
+      try {
+        return fs.statSync(d).isDirectory();
+      } catch {
+        return false;
+      }
+    });
+  } catch {
+    return null;
+  }
+  for (const dir of dirs) {
+    try {
+      const files = fs.readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
+      for (const file of files) {
+        if (file.replace(".jsonl", "") === sessionId) {
+          return path.join(dir, file);
+        }
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+function cwdToProjectSlug(cwd) {
+  return cwd.replace(/[:\\/]/g, "-").replace(/^-+|-+$/g, "");
+}
+function findSessionByCwd(cwd) {
+  const slug = cwdToProjectSlug(cwd ?? process.cwd());
+  const projectDir = path.join(claudeProjectsDir(), slug);
+  if (!fs.existsSync(projectDir)) return null;
+  let files = [];
+  try {
+    files = fs.readdirSync(projectDir).filter((f) => f.endsWith(".jsonl"));
+  } catch {
+    return null;
+  }
+  let latestFile = null;
+  let latestTime = 0;
+  for (const file of files) {
+    const fullPath = path.join(projectDir, file);
+    try {
+      const mtime = fs.statSync(fullPath).mtimeMs;
+      if (mtime > latestTime) {
+        latestTime = mtime;
+        latestFile = fullPath;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return latestFile;
+}
+function findLatestSession() {
+  const baseDir = claudeProjectsDir();
+  if (!fs.existsSync(baseDir)) {
+    console.warn(`[driftcli] Session directory not found: ${baseDir}`);
+    return null;
+  }
+  let dirs = [];
+  try {
+    dirs = fs.readdirSync(baseDir).map((d) => path.join(baseDir, d)).filter((d) => {
+      try {
+        return fs.statSync(d).isDirectory();
+      } catch {
+        return false;
+      }
+    });
+  } catch (err) {
+    console.warn(`[driftcli] Could not read session directory: ${err instanceof Error ? err.message : err}`);
+    return null;
+  }
+  let latestFile = null;
+  let latestTime = 0;
+  for (const dir of dirs) {
+    let files = [];
+    try {
+      files = fs.readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
+    } catch {
+      continue;
+    }
+    for (const file of files) {
+      const fullPath = path.join(dir, file);
+      try {
+        const mtime = fs.statSync(fullPath).mtimeMs;
+        if (mtime > latestTime) {
+          latestTime = mtime;
+          latestFile = fullPath;
+        }
+      } catch {
+        continue;
+      }
+    }
+  }
+  return latestFile;
+}
+var fs, path, os;
+var init_claude_parser = __esm({
+  "src/watchers/claude-parser.ts"() {
+    "use strict";
+    fs = __toESM(require("fs"));
+    path = __toESM(require("path"));
+    os = __toESM(require("os"));
+  }
+});
+
+// src/watchers/claude-adapter.ts
+var ClaudeAdapter;
+var init_claude_adapter = __esm({
+  "src/watchers/claude-adapter.ts"() {
+    "use strict";
+    init_claude_parser();
+    ClaudeAdapter = class {
+      constructor() {
+        this.name = "claude";
+      }
+      canParse(filePath) {
+        return filePath.includes(".claude") && filePath.endsWith(".jsonl");
+      }
+      parse(filePath) {
+        return parseJSONL(filePath);
+      }
+      findLatest() {
+        return findSessionByCwd() ?? findLatestSession();
+      }
+    };
+  }
+});
+
+// src/watchers/gemini-adapter.ts
+var fs2, path2, os2, GeminiAdapter;
+var init_gemini_adapter = __esm({
+  "src/watchers/gemini-adapter.ts"() {
+    "use strict";
+    fs2 = __toESM(require("fs"));
+    path2 = __toESM(require("path"));
+    os2 = __toESM(require("os"));
+    GeminiAdapter = class {
+      constructor() {
+        this.name = "gemini";
+      }
+      canParse(filePath) {
+        return filePath.includes(".gemini") && filePath.endsWith(".jsonl");
+      }
+      parse(filePath) {
+        const raw = fs2.readFileSync(filePath, "utf-8");
+        const lines = raw.split("\n").filter((l) => l.trim());
+        const messages = [];
+        let index = 0;
+        for (const line of lines) {
+          try {
+            const entry = JSON.parse(line);
+            if (entry.role !== "user" && entry.role !== "model") continue;
+            const text = (entry.parts ?? []).map((p) => p.text ?? "").join("\n").trim();
+            if (!text) continue;
+            const ts = entry.timestamp ? new Date(entry.timestamp).getTime() : Date.now();
+            messages.push({
+              id: `gemini-${index++}`,
+              role: entry.role === "model" ? "assistant" : "user",
+              content: text,
+              timestamp: isFinite(ts) ? ts : Date.now()
+            });
+          } catch {
+          }
+        }
+        return messages;
+      }
+      findLatest() {
+        const geminiTmp = path2.join(
+          process.env.DRIFTCLI_HOME ?? os2.homedir(),
+          ".gemini",
+          "tmp"
+        );
+        if (!fs2.existsSync(geminiTmp)) return null;
+        let latestFile = null;
+        let latestTime = 0;
+        try {
+          const sessionDirs = fs2.readdirSync(geminiTmp).map((d) => path2.join(geminiTmp, d)).filter((d) => {
+            try {
+              return fs2.statSync(d).isDirectory();
+            } catch {
+              return false;
+            }
+          });
+          for (const dir of sessionDirs) {
+            try {
+              const files = fs2.readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
+              for (const file of files) {
+                const fullPath = path2.join(dir, file);
+                try {
+                  const mtime = fs2.statSync(fullPath).mtimeMs;
+                  if (mtime > latestTime) {
+                    latestTime = mtime;
+                    latestFile = fullPath;
+                  }
+                } catch {
+                  continue;
+                }
+              }
+            } catch {
+              continue;
+            }
+          }
+        } catch {
+          return null;
+        }
+        return latestFile;
+      }
+    };
+  }
+});
+
+// src/watchers/codex-adapter.ts
+var fs3, path3, os3, CodexAdapter;
+var init_codex_adapter = __esm({
+  "src/watchers/codex-adapter.ts"() {
+    "use strict";
+    fs3 = __toESM(require("fs"));
+    path3 = __toESM(require("path"));
+    os3 = __toESM(require("os"));
+    CodexAdapter = class {
+      constructor() {
+        this.name = "codex";
+      }
+      canParse(filePath) {
+        return filePath.includes(".codex") && filePath.endsWith(".jsonl");
+      }
+      parse(filePath) {
+        const raw = fs3.readFileSync(filePath, "utf-8");
+        const lines = raw.split("\n").filter((l) => l.trim());
+        const messages = [];
+        let index = 0;
+        for (const line of lines) {
+          try {
+            const entry = JSON.parse(line);
+            if (entry.role !== "user" && entry.role !== "assistant") continue;
+            let text = "";
+            if (typeof entry.content === "string") {
+              text = entry.content.trim();
+            } else if (Array.isArray(entry.content)) {
+              text = entry.content.filter((b) => b.type === "text" && typeof b.text === "string").map((b) => b.text.trim()).join("\n").trim();
+            }
+            if (!text) continue;
+            let ts = Date.now();
+            if (entry.timestamp) {
+              const parsed = typeof entry.timestamp === "number" ? entry.timestamp : new Date(entry.timestamp).getTime();
+              if (isFinite(parsed)) ts = parsed;
+            }
+            messages.push({
+              id: `codex-${index++}`,
+              role: entry.role,
+              content: text,
+              timestamp: ts
+            });
+          } catch {
+          }
+        }
+        return messages;
+      }
+      findLatest() {
+        const codexDir = path3.join(
+          process.env.DRIFTCLI_HOME ?? os3.homedir(),
+          ".codex"
+        );
+        if (!fs3.existsSync(codexDir)) return null;
+        let latestFile = null;
+        let latestTime = 0;
+        const scan = (dir) => {
+          try {
+            for (const entry of fs3.readdirSync(dir)) {
+              const fullPath = path3.join(dir, entry);
+              try {
+                const stat = fs3.statSync(fullPath);
+                if (stat.isDirectory()) {
+                  scan(fullPath);
+                } else if (entry.endsWith(".jsonl") && stat.mtimeMs > latestTime) {
+                  latestTime = stat.mtimeMs;
+                  latestFile = fullPath;
+                }
+              } catch {
+                continue;
+              }
+            }
+          } catch {
+          }
+        };
+        scan(codexDir);
+        return latestFile;
+      }
+    };
+  }
+});
+
+// src/watchers/adapter-registry.ts
+function detectAdapter(filePath) {
+  return ADAPTERS.find((a) => a.canParse(filePath)) ?? ADAPTERS[0];
+}
+var ADAPTERS;
+var init_adapter_registry = __esm({
+  "src/watchers/adapter-registry.ts"() {
+    "use strict";
+    init_claude_adapter();
+    init_gemini_adapter();
+    init_codex_adapter();
+    ADAPTERS = [new ClaudeAdapter(), new GeminiAdapter(), new CodexAdapter()];
+  }
+});
+
+// src/watchers/session-resolver.ts
+var SessionResolver;
+var init_session_resolver = __esm({
+  "src/watchers/session-resolver.ts"() {
+    "use strict";
+    init_claude_parser();
+    init_claude_adapter();
+    init_adapter_registry();
+    SessionResolver = class {
+      constructor(cacheTtlMs = 5e3, adapter) {
+        this.cacheTtlMs = cacheTtlMs;
+        this.cached = null;
+        this.adapter = adapter ?? new ClaudeAdapter();
+      }
+      resolve() {
+        if (this.cached && this.cached.expiresAt > Date.now()) {
+          return this.cached.file;
+        }
+        const result = this.resolveFromEnv() ?? this.resolveFromCwd() ?? findLatestSession();
+        if (result) {
+          this.cached = { file: result, expiresAt: Date.now() + this.cacheTtlMs };
+        } else {
+          this.cached = null;
+        }
+        return result;
+      }
+      /** Return the adapter to use for parsing the resolved session file. */
+      getAdapter(filePath) {
+        if (filePath) return detectAdapter(filePath);
+        return this.adapter;
+      }
+      /** Force the next call to re-resolve rather than use the cache. */
+      invalidate() {
+        this.cached = null;
+      }
+      resolveFromCwd() {
+        const file = findSessionByCwd();
+        if (file && process.env.DRIFTCLI_DEBUG) {
+          const slug = file.split(/[\\/]/).slice(-2, -1)[0];
+          console.warn(`[driftcli] Session resolved via CWD match: ${slug}`);
+        }
+        return file;
+      }
+      resolveFromEnv() {
+        const sessionId = process.env.DRIFTCLI_SESSION_ID;
+        if (!sessionId) return null;
+        const found = findSessionByUUID(sessionId);
+        if (!found) {
+          console.warn(`[driftcli] DRIFTCLI_SESSION_ID="${sessionId}" set but no matching .jsonl found \u2014 falling back to newest file`);
+        }
+        return found;
+      }
+    };
+  }
+});
+
+// src/core/types.ts
+function scoreToLevel(score) {
+  if (score < 30) return "fresh";
+  if (score <= 60) return "warming";
+  if (score <= 80) return "drifting";
+  return "polluted";
+}
+var DEFAULT_WEIGHTS;
+var init_types = __esm({
+  "src/core/types.ts"() {
+    "use strict";
+    DEFAULT_WEIGHTS = {
+      contextSaturation: 0.2,
+      topicScatter: 0.12,
+      uncertaintySignals: 0.15,
+      codeInconsistency: 0.08,
+      repetition: 0.2,
+      goalDistance: 0.15,
+      confidenceDrift: 0.1
+    };
+  }
+});
+
+// src/core/topic-analyzer.ts
+function calculateTopicEntropy(messages) {
+  if (messages.length < 3) return 0;
+  const capped = messages.length > TOPIC_ENTROPY_MSG_CAP ? messages.slice(-TOPIC_ENTROPY_MSG_CAP) : messages;
+  const windows = createWindows(capped, 3);
+  if (windows.length < 2) return 0;
+  const corpus = windows.map((w) => w.join(" "));
+  const tfidfVectors = buildTfidfVectors(corpus);
+  const consecutiveSims = [];
+  for (let i = 1; i < tfidfVectors.length; i++) {
+    consecutiveSims.push(cosineSimilarity(tfidfVectors[i - 1], tfidfVectors[i]));
+  }
+  const avgConsecutive = consecutiveSims.reduce((a, b) => a + b, 0) / consecutiveSims.length;
+  const wideSims = [];
+  for (let i = 3; i < tfidfVectors.length; i += 3) {
+    wideSims.push(cosineSimilarity(tfidfVectors[i - 3], tfidfVectors[i]));
+  }
+  const avgWide = wideSims.length > 0 ? wideSims.reduce((a, b) => a + b, 0) / wideSims.length : avgConsecutive;
+  const blendedSimilarity = avgConsecutive * 0.6 + avgWide * 0.4;
+  const entropy = Math.round((1 - blendedSimilarity) * 100);
+  return Math.min(100, Math.max(0, entropy));
+}
+function calculateAnchorDrift(messages, userGoal) {
+  if (messages.length < 4) return 0;
+  const userMessages = messages.filter((m) => m.role === "user");
+  if (userMessages.length < 2) return 0;
+  const anchorDoc = userGoal ? userGoal : userMessages.slice(0, Math.min(2, userMessages.length)).map((m) => m.content).join(" ");
+  const recentMessages = messages.slice(-3);
+  const recentDoc = recentMessages.map((m) => m.content).join(" ");
+  if (!anchorDoc.trim() || !recentDoc.trim()) return 0;
+  const corpus = [anchorDoc, recentDoc];
+  const vectors = buildTfidfVectors(corpus);
+  if (vectors.length < 2) return 0;
+  const similarity = cosineSimilarity(vectors[0], vectors[1]);
+  if (typeof similarity !== "number" || isNaN(similarity)) return 0;
+  const rawDrift = 1 - similarity;
+  const score = Math.round(Math.min(100, rawDrift * 140));
+  return Math.max(0, isNaN(score) ? 0 : score);
+}
+function calculateGoalDriftCheckpoints(messages, userGoal) {
+  if (messages.length < 4) {
+    return {
+      checkpoints: [],
+      trajectory: "stable",
+      averageScore: 0,
+      startToEndDrift: 0
+    };
+  }
+  const userMessages = messages.filter((m) => m.role === "user");
+  if (userMessages.length < 2) {
+    return {
+      checkpoints: [],
+      trajectory: "stable",
+      averageScore: 0,
+      startToEndDrift: 0
+    };
+  }
+  const anchorTexts = userGoal ? [userGoal] : userMessages.slice(0, Math.min(2, userMessages.length));
+  const anchorDoc = Array.isArray(anchorTexts) ? anchorTexts.map((m) => typeof m === "string" ? m : m.content).join(" ") : anchorTexts;
+  if (!anchorDoc.trim()) {
+    return {
+      checkpoints: [],
+      trajectory: "stable",
+      averageScore: 0,
+      startToEndDrift: 0
+    };
+  }
+  const checkpoints = [];
+  const positions = [0, 25, 50, 75, 100];
+  for (const pos of positions) {
+    const endIdx = Math.max(1, Math.floor(messages.length * pos / 100));
+    const windowMessages = messages.slice(0, endIdx);
+    const windowDoc = windowMessages.map((m) => m.content).join(" ");
+    if (!windowDoc.trim()) {
+      checkpoints.push({
+        position: pos,
+        similarity: 1,
+        // Empty window = same as anchor
+        driftScore: 0
+      });
+      continue;
+    }
+    const corpus = [anchorDoc, windowDoc];
+    const vectors = buildTfidfVectors(corpus);
+    if (vectors.length < 2) {
+      checkpoints.push({
+        position: pos,
+        similarity: pos === 0 ? 1 : 0,
+        driftScore: pos === 0 ? 0 : 100
+      });
+      continue;
+    }
+    const similarity = cosineSimilarity(vectors[0], vectors[1]);
+    const validSimilarity = typeof similarity === "number" && !isNaN(similarity) ? similarity : 0;
+    const driftScore = Math.round(
+      Math.min(100, (1 - validSimilarity) * 140)
+    );
+    checkpoints.push({
+      position: pos,
+      similarity: Math.max(0, Math.min(1, validSimilarity)),
+      driftScore: Math.max(0, isNaN(driftScore) ? 0 : driftScore)
+    });
+  }
+  const scores = checkpoints.map((c) => c.driftScore);
+  const trajectory = detectTrajectory(scores);
+  const driftsAfterStart = scores.slice(1);
+  const averageScore = driftsAfterStart.length ? Math.round(driftsAfterStart.reduce((a, b) => a + b, 0) / driftsAfterStart.length) : 0;
+  const startToEndDrift = checkpoints.length > 1 ? checkpoints[checkpoints.length - 1].driftScore : 0;
+  return {
+    checkpoints,
+    trajectory,
+    averageScore,
+    startToEndDrift
+  };
+}
+function detectTrajectory(scores) {
+  if (scores.length < 3) return "stable";
+  const changes = [];
+  for (let i = 1; i < scores.length; i++) {
+    changes.push(scores[i] - scores[i - 1]);
+  }
+  const avgChange = changes.reduce((a, b) => a + b, 0) / changes.length;
+  const volatility = Math.sqrt(
+    changes.reduce((sum, c) => sum + (c - avgChange) ** 2, 0) / changes.length
+  );
+  const declineCount = changes.filter((c) => c < 0).length;
+  const increaseCount = changes.filter((c) => c > 0).length;
+  const hasSharpDrop = changes.some((c) => c < -20);
+  const isGradualDecline = declineCount >= changes.length * 0.6 && avgChange < -3 && !hasSharpDrop;
+  const isRecovery = scores[0] > 20 && scores.some((s, i) => i > 0 && i < scores.length - 1 && s > scores[scores.length - 1] + 15) && changes[changes.length - 1] > 0;
+  const isVolatile = volatility > 20 && increaseCount > 0 && declineCount > 0;
+  if (hasSharpDrop) return "sharp_drop";
+  if (isGradualDecline) return "gradual_decline";
+  if (isRecovery) return "recovery";
+  if (isVolatile) return "volatile";
+  return "stable";
+}
+function buildTfidfVectors(corpus) {
+  const n = corpus.length;
+  if (n === 0) return [];
+  const tokenized = corpus.map((doc) => tokenize(doc));
+  const df = /* @__PURE__ */ new Map();
+  for (const tokens of tokenized) {
+    const unique = new Set(tokens);
+    for (const term of unique) {
+      df.set(term, (df.get(term) || 0) + 1);
+    }
+  }
+  return tokenized.map((tokens) => {
+    const vector = /* @__PURE__ */ new Map();
+    if (tokens.length === 0) return vector;
+    const tf = /* @__PURE__ */ new Map();
+    for (const term of tokens) {
+      tf.set(term, (tf.get(term) || 0) + 1);
+    }
+    for (const [term, count] of tf) {
+      const termFreq = count / tokens.length;
+      const docFreq = df.get(term) || 1;
+      const idf = Math.log((n + 1) / (docFreq + 1)) + 1;
+      vector.set(term, termFreq * idf);
+    }
+    return vector;
+  });
+}
+function cosineSimilarity(a, b) {
+  if (a.size === 0 || b.size === 0) return 0;
+  let dotProduct = 0;
+  let normA = 0;
+  let normB = 0;
+  for (const [term, weightA] of a) {
+    normA += weightA * weightA;
+    const weightB = b.get(term);
+    if (weightB !== void 0) {
+      dotProduct += weightA * weightB;
+    }
+  }
+  for (const [, weightB] of b) {
+    normB += weightB * weightB;
+  }
+  normA = Math.max(0, normA);
+  normB = Math.max(0, normB);
+  const denominator = Math.sqrt(normA) * Math.sqrt(normB);
+  if (denominator === 0 || isNaN(denominator)) return 0;
+  const result = dotProduct / denominator;
+  return isNaN(result) ? 0 : Math.max(0, Math.min(1, result));
+}
+function tokenize(text) {
+  const withoutCode = text.replace(/```[\s\S]*?```/g, " ");
+  return withoutCode.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((w) => w.length >= 4 && !STOP_WORDS.has(w));
+}
+function createWindows(messages, windowSize) {
+  const windows = [];
+  for (let i = 0; i <= messages.length - windowSize; i++) {
+    const windowTexts = messages.slice(i, i + windowSize).map((m) => {
+      const withoutCode = m.content.replace(/```[\s\S]*?```/g, " ");
+      return withoutCode.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((w) => w.length >= 4 && !STOP_WORDS.has(w));
+    }).flat();
+    windows.push(windowTexts);
+  }
+  return windows;
+}
+function extractTopTerms(messages, n = 5) {
+  const freq = /* @__PURE__ */ new Map();
+  for (const msg of messages) {
+    for (const term of tokenize(msg.content)) {
+      freq.set(term, (freq.get(term) ?? 0) + 1);
+    }
+  }
+  return [...freq.entries()].sort((a, b) => b[1] - a[1]).slice(0, n).map(([term]) => term);
+}
+function extractNgrams(text, n = 3) {
+  const tokens = tokenize(text).filter((w) => !/^\d/.test(w));
+  if (tokens.length < n) return /* @__PURE__ */ new Set();
+  const ngrams = /* @__PURE__ */ new Set();
+  for (let i = 0; i <= tokens.length - n; i++) {
+    ngrams.add(tokens.slice(i, i + n).join(" "));
+  }
+  return ngrams;
+}
+function fleschKincaidGrade(text) {
+  const sentences = countSentences(text);
+  const words = countWords(text);
+  const syllables = countSyllables(text);
+  if (sentences === 0 || words === 0) return 0;
+  const grade = 0.39 * (words / sentences) + 11.8 * (syllables / words) - 15.59;
+  return Math.max(0, grade);
+}
+function countSentences(text) {
+  const matches = text.match(/[.!?]+/g);
+  return Math.max(1, matches ? matches.length : 1);
+}
+function countWords(text) {
+  return text.split(/\s+/).filter((w) => w.length > 0).length;
+}
+function countSyllables(text) {
+  const words = text.toLowerCase().split(/\s+/).filter((w) => w.length > 0);
+  let total = 0;
+  for (const word of words) {
+    total += countWordSyllables(word);
+  }
+  return Math.max(1, total);
+}
+function countWordSyllables(word) {
+  const clean = word.replace(/[^a-z]/g, "");
+  if (clean.length <= 2) return 1;
+  const vowelGroups = clean.match(/[aeiouy]+/g);
+  let count = vowelGroups ? vowelGroups.length : 1;
+  if (clean.endsWith("e") && count > 1) count--;
+  if (clean.endsWith("le") && clean.length > 2 && !/[aeiouy]/.test(clean[clean.length - 3])) count++;
+  return Math.max(1, count);
+}
+var TOPIC_ENTROPY_MSG_CAP, STOP_WORDS;
+var init_topic_analyzer = __esm({
+  "src/core/topic-analyzer.ts"() {
+    "use strict";
+    TOPIC_ENTROPY_MSG_CAP = 150;
+    STOP_WORDS = /* @__PURE__ */ new Set([
+      "about",
+      "after",
+      "also",
+      "been",
+      "before",
+      "being",
+      "between",
+      "both",
+      "came",
+      "come",
+      "could",
+      "each",
+      "from",
+      "have",
+      "here",
+      "herself",
+      "himself",
+      "into",
+      "just",
+      "like",
+      "make",
+      "many",
+      "might",
+      "more",
+      "most",
+      "much",
+      "must",
+      "never",
+      "only",
+      "other",
+      "over",
+      "said",
+      "same",
+      "should",
+      "since",
+      "some",
+      "still",
+      "such",
+      "take",
+      "than",
+      "that",
+      "their",
+      "them",
+      "then",
+      "there",
+      "these",
+      "they",
+      "this",
+      "those",
+      "through",
+      "under",
+      "very",
+      "want",
+      "well",
+      "were",
+      "what",
+      "when",
+      "where",
+      "which",
+      "while",
+      "will",
+      "with",
+      "would",
+      "your",
+      "does",
+      "done",
+      "doing",
+      "going",
+      "know",
+      "need",
+      "please",
+      "really",
+      "right",
+      "sure",
+      "tell",
+      "thank",
+      "thanks",
+      "that",
+      "think",
+      "though",
+      "using",
+      "want",
+      "work",
+      "yeah",
+      "actually",
+      "already",
+      "always",
+      "another",
+      "anything",
+      "around",
+      "because",
+      "better",
+      "called",
+      "cannot",
+      "didnt",
+      "doesnt",
+      "dont",
+      "enough",
+      "every",
+      "example",
+      "first",
+      "getting",
+      "given",
+      "gonna",
+      "great",
+      "hasnt",
+      "helps",
+      "heres",
+      "however",
+      "instead",
+      "keep",
+      "looking",
+      "means",
+      "maybe",
+      "nothing",
+      "people",
+      "point",
+      "probably",
+      "something",
+      "sorry",
+      "start",
+      "still",
+      "things",
+      "trying",
+      "understand",
+      "used",
+      "without",
+      "youre",
+      // Chat-speak
+      "therre",
+      "thnx",
+      "thanx",
+      "wanna",
+      "kinda",
+      "gotta",
+      "lemme",
+      "soooo",
+      "sooo",
+      "okayy",
+      "yeahh",
+      "nope",
+      "yep",
+      // Generic non-informative tech words
+      "file",
+      "code",
+      "function",
+      "variable",
+      "method",
+      "class",
+      "type",
+      "value",
+      "data",
+      "list",
+      "array",
+      "object",
+      "string",
+      "number",
+      "return",
+      "output",
+      "input",
+      "result",
+      "issue",
+      "problem",
+      "question",
+      "answer",
+      "approach",
+      "solution",
+      "basically",
+      "stuff",
+      "thing",
+      "part",
+      "case",
+      "line",
+      "step",
+      // Dutch
+      "deze",
+      "voor",
+      "maar",
+      "ook",
+      "zijn",
+      "niet",
+      "meer",
+      "naar",
+      "hier",
+      "goed",
+      "heel",
+      "hoe",
+      "als",
+      "dan",
+      "alle",
+      "veel",
+      "omdat",
+      "welke",
+      "weten",
+      "alleen",
+      "iets",
+      "andere",
+      "zonder",
+      "hebben",
+      "wordt",
+      "kunnen",
+      "moeten",
+      "willen",
+      "zouden",
+      "eigenlijk",
+      "misschien",
+      "graag",
+      "bedankt",
+      "prima",
+      "klopt",
+      "precies",
+      // German
+      "aber",
+      "auch",
+      "dein",
+      "denn",
+      "doch",
+      "durch",
+      "eine",
+      "ganz",
+      "gern",
+      "hier",
+      "jede",
+      "kann",
+      "mehr",
+      "nach",
+      "noch",
+      "ohne",
+      "oder",
+      "sein",
+      "sich",
+      "\xFCber",
+      "unter",
+      "viel",
+      "weil",
+      "wenn",
+      "wird",
+      "diese",
+      "haben",
+      "jetzt",
+      "muss",
+      "nicht",
+      "sehr",
+      "danke",
+      "bitte",
+      "genau",
+      "vielleicht",
+      "eigentlich",
+      "bestimmt",
+      // French
+      "aussi",
+      "avec",
+      "bien",
+      "cette",
+      "dans",
+      "elle",
+      "\xEAtre",
+      "fait",
+      "mais",
+      "m\xEAme",
+      "nous",
+      "pour",
+      "sans",
+      "sont",
+      "tout",
+      "tr\xE8s",
+      "vous",
+      "apr\xE8s",
+      "autre",
+      "avant",
+      "avoir",
+      "comme",
+      "encore",
+      "entre",
+      "faire",
+      "leurs",
+      "merci",
+      "notre",
+      "parce",
+      "plus",
+      "quand",
+      "quel",
+      "sera",
+      "tous",
+      "votre",
+      "donc",
+      "peut",
+      // Spanish
+      "algo",
+      "antes",
+      "bien",
+      "cada",
+      "como",
+      "cual",
+      "desde",
+      "donde",
+      "esta",
+      "esto",
+      "hace",
+      "hasta",
+      "luego",
+      "mejor",
+      "mismo",
+      "mucho",
+      "nada",
+      "otro",
+      "para",
+      "pero",
+      "poco",
+      "puede",
+      "sino",
+      "solo",
+      "tambi\xE9n",
+      "tiene",
+      "todo",
+      "todos",
+      "usted",
+      "sobre",
+      "gracias",
+      "bueno",
+      "creo",
+      "ahora",
+      "entonces",
+      "realmente",
+      "bastante",
+      // Portuguese
+      "agora",
+      "algo",
+      "antes",
+      "cada",
+      "como",
+      "desde",
+      "esta",
+      "isso",
+      "mais",
+      "muito",
+      "nada",
+      "onde",
+      "para",
+      "pode",
+      "qual",
+      "quando",
+      "quem",
+      "ser\xE1",
+      "seus",
+      "sobre",
+      "tamb\xE9m",
+      "tudo",
+      "voc\xEA",
+      "obrigado",
+      "obrigada",
+      "acho",
+      "ent\xE3o",
+      "realmente",
+      "bastante"
+    ]);
+  }
+});
+
+// src/core/contradiction-detector.ts
+function countContradictions(assistantMessages) {
+  let count = 0;
+  for (let i = 0; i < assistantMessages.length; i++) {
+    const msg = assistantMessages[i];
+    const text = msg.content.toLowerCase();
+    count += countPatternMatches(text, CORRECTION_PATTERNS);
+    if (i > 0) {
+      const prevText = assistantMessages[i - 1].content.toLowerCase();
+      count += detectReversals(prevText, text);
+    }
+  }
+  return count;
+}
+function countPatternMatches(text, patterns) {
+  let count = 0;
+  for (const pattern of patterns) {
+    const matches = text.match(pattern);
+    if (matches) count += matches.length;
+  }
+  return count;
+}
+function detectReversals(prevText, currentText) {
+  let reversals = 0;
+  const hasReversalSignal = currentText.includes("actually") || currentText.includes("however") || currentText.includes("but ") || currentText.includes("instead") || // Dutch
+  currentText.includes("eigenlijk") || currentText.includes("echter") || currentText.includes("maar ") || // German
+  currentText.includes("eigentlich") || currentText.includes("allerdings") || currentText.includes("aber ") || currentText.includes("stattdessen") || // French
+  currentText.includes("en fait") || currentText.includes("cependant") || currentText.includes("mais ") || currentText.includes("plut\xF4t") || // Spanish
+  currentText.includes("en realidad") || currentText.includes("sin embargo") || currentText.includes("pero ") || currentText.includes("en cambio") || // Portuguese
+  currentText.includes("na verdade") || currentText.includes("no entanto") || currentText.includes("mas ") || currentText.includes("em vez");
+  if (hasReversalSignal) {
+    for (const negation of NEGATION_PAIRS) {
+      if (prevText.includes(negation.positive) && currentText.includes(negation.negative)) {
+        reversals++;
+      }
+    }
+  }
+  return reversals;
+}
+var CORRECTION_PATTERNS, NEGATION_PAIRS;
+var init_contradiction_detector = __esm({
+  "src/core/contradiction-detector.ts"() {
+    "use strict";
+    CORRECTION_PATTERNS = [
+      // English — explicit corrections
+      /i apologize/gi,
+      /i was (?:wrong|mistaken|incorrect)/gi,
+      /let me correct/gi,
+      /let me (?:re-?do|re-?write|re-?phrase|fix) that/gi,
+      /i (?:need to|should) clarify/gi,
+      /upon (?:further )?(?:review|reflection|consideration)/gi,
+      /i previously (?:said|mentioned|stated|suggested)/gi,
+      /(?:ignore|disregard) (?:my |what i )(?:previous|earlier)/gi,
+      /i made (?:a |an )?(?:error|mistake)/gi,
+      /correction:/gi,
+      /wait[,.]? (?:that's|i|let me)/gi,
+      /actually[,.]? (?:that|i was|you're right|the|no)/gi,
+      /you'?re (?:right|correct)[,.]? (?:i|let|my|the)/gi,
+      /my (?:earlier|previous) (?:response|answer|suggestion) was/gi,
+      /i (?:over|under)(?:looked|estimated|stated)/gi,
+      /sorry[,.]? (?:i|that|for|about|let)/gi,
+      /i (?:should have|shouldn't have|misspoke)/gi,
+      /(?:good|fair) point[,.]? (?:i|let|you)/gi,
+      /i stand corrected/gi,
+      /to clarify (?:my|what|the)/gi,
+      /(?:that|this) (?:is|was) (?:not )?(?:quite )?(?:right|correct|accurate)/gi,
+      /i (?:incorrectly|mistakenly) (?:said|stated|suggested|assumed)/gi,
+      /my (?:bad|apologies|mistake)/gi,
+      /i (?:was |)(?:confused|confusing)/gi,
+      /(?:let me|i'll) (?:start over|rethink|reconsider)/gi,
+      // Dutch — self-correction patterns
+      /(?:sorry|excuses)[,.]? (?:ik|dat|voor)/gi,
+      /ik had (?:het |)(?:fout|mis|verkeerd)/gi,
+      /laat me (?:dat |het |)(?:corrigeren|verbeteren|herstellen)/gi,
+      /dat (?:klopt|klopte) (?:niet|eigenlijk niet)/gi,
+      /ik (?:bedoelde|bedoel) eigenlijk/gi,
+      /bij nader inzien/gi,
+      /mijn fout/gi,
+      // German — self-correction patterns
+      /(?:entschuldigung|tut mir leid)[,.]? (?:ich|das|für)/gi,
+      /ich (?:war|lag) (?:falsch|daneben)/gi,
+      /lass mich (?:das |)(?:korrigieren|berichtigen|richtigstellen)/gi,
+      /das (?:stimmt|stimmte) (?:nicht|so nicht)/gi,
+      /ich (?:meinte|meine) eigentlich/gi,
+      /bei näherer betrachtung/gi,
+      /mein fehler/gi,
+      /ich muss mich korrigieren/gi,
+      /ich habe mich (?:geirrt|vertan|getäuscht)/gi,
+      // French — self-correction patterns
+      /(?:je m'excuse|pardon|désolé)[,.]? (?:je|c'|pour)/gi,
+      /j'(?:avais|ai) (?:tort|fait une erreur)/gi,
+      /laissez-moi (?:corriger|rectifier)/gi,
+      /(?:c'est|c'était) (?:pas correct|inexact|une erreur)/gi,
+      /en fait[,.]? (?:c'est|je|il|non)/gi,
+      /après (?:réflexion|vérification)/gi,
+      /mon erreur/gi,
+      /je (?:me suis trompé|dois rectifier)/gi,
+      // Spanish — self-correction patterns
+      /(?:perdón|disculpa|lo siento)[,.]? (?:yo|eso|por)/gi,
+      /(?:estaba|estuve) (?:equivocado|mal|incorrecto)/gi,
+      /(?:déjame|permíteme) (?:corregir|rectificar)/gi,
+      /(?:eso|esto) (?:no es|no era) (?:correcto|exacto)/gi,
+      /en realidad[,.]? (?:es|yo|no|el)/gi,
+      /pensándolo (?:bien|mejor)/gi,
+      /mi error/gi,
+      /me (?:equivoqué|confundí)/gi,
+      // Portuguese — self-correction patterns
+      /(?:desculpe?|perdão)[,.]? (?:eu|isso|por)/gi,
+      /eu (?:estava|estive) (?:errado|equivocado|enganado)/gi,
+      /(?:deixe-me|permita-me) (?:corrigir|retificar)/gi,
+      /(?:isso|isto) (?:não é|não estava) (?:correto|certo)/gi,
+      /na verdade[,.]? (?:é|eu|não|o)/gi,
+      /pensando (?:bem|melhor)/gi,
+      /meu erro/gi,
+      /eu (?:me enganei|me confundi|errei)/gi
+    ];
+    NEGATION_PAIRS = [
+      // English
+      { positive: "you should", negative: "you shouldn't" },
+      { positive: "you should", negative: "you should not" },
+      { positive: "recommend", negative: "don't recommend" },
+      { positive: "recommend", negative: "do not recommend" },
+      { positive: "best practice", negative: "not.+best practice" },
+      { positive: "you can", negative: "you can't" },
+      { positive: "you can", negative: "you cannot" },
+      { positive: "safe to", negative: "not safe to" },
+      { positive: "correct", negative: "incorrect" },
+      // Dutch
+      { positive: "je moet", negative: "je moet niet" },
+      { positive: "je kunt", negative: "je kunt niet" },
+      { positive: "aanbevolen", negative: "niet aanbevolen" },
+      { positive: "veilig", negative: "niet veilig" },
+      // German
+      { positive: "du solltest", negative: "du solltest nicht" },
+      { positive: "du kannst", negative: "du kannst nicht" },
+      { positive: "empfohlen", negative: "nicht empfohlen" },
+      { positive: "sicher", negative: "nicht sicher" },
+      // French
+      { positive: "vous devriez", negative: "vous ne devriez pas" },
+      { positive: "vous pouvez", negative: "vous ne pouvez pas" },
+      { positive: "recommand\xE9", negative: "pas recommand\xE9" },
+      { positive: "correct", negative: "pas correct" },
+      // Spanish
+      { positive: "deber\xEDas", negative: "no deber\xEDas" },
+      { positive: "puedes", negative: "no puedes" },
+      { positive: "recomendado", negative: "no recomendado" },
+      { positive: "seguro", negative: "no es seguro" },
+      // Portuguese
+      { positive: "voc\xEA deveria", negative: "voc\xEA n\xE3o deveria" },
+      { positive: "voc\xEA pode", negative: "voc\xEA n\xE3o pode" },
+      { positive: "recomendado", negative: "n\xE3o recomendado" },
+      { positive: "seguro", negative: "n\xE3o \xE9 seguro" }
+    ];
+  }
+});
+
+// src/core/confidence-analyzer.ts
+function detectHedgingLanguage(messageContent) {
+  if (!messageContent || messageContent.length < 10) return 0;
+  const lower = messageContent.toLowerCase();
+  let hedgingCount = 0;
+  let totalRelevantWords = 0;
+  for (const patterns of Object.values(HEDGING_PATTERNS)) {
+    for (const pattern of patterns) {
+      const regex = new RegExp(`\\b${pattern}\\b`, "gi");
+      const matches = lower.match(regex);
+      if (matches) {
+        hedgingCount += matches.length;
+      }
+    }
+  }
+  const words = lower.split(/\s+/).filter((w) => w.length > 2).length;
+  totalRelevantWords = Math.max(words, 1);
+  const hedgingRatio = hedgingCount / totalRelevantWords;
+  return Math.min(100, Math.round(hedgingRatio * 200));
+}
+function trackConfidenceTrend(messages) {
+  const assistantMessages = messages.filter((m) => m.role === "assistant");
+  if (assistantMessages.length < 2) return 0;
+  const earlyMessages = assistantMessages.slice(0, Math.ceil(assistantMessages.length / 3));
+  const lateMessages = assistantMessages.slice(Math.floor(assistantMessages.length * 2 / 3));
+  const earlyAvg = earlyMessages.reduce((sum, m) => sum + detectHedgingLanguage(m.content), 0) / earlyMessages.length;
+  const lateAvg = lateMessages.reduce((sum, m) => sum + detectHedgingLanguage(m.content), 0) / lateMessages.length;
+  const trendScore = Math.max(0, lateAvg - earlyAvg);
+  return Math.round(trendScore);
+}
+function detectNegationReversals(messages) {
+  const assistantMessages = messages.filter((m) => m.role === "assistant");
+  if (assistantMessages.length < 2) return 0;
+  let reversalCount = 0;
+  for (const msg of assistantMessages) {
+    const lower = msg.content.toLowerCase();
+    for (const pattern of HEDGING_PATTERNS.negationPatterns) {
+      const regex = new RegExp(`\\b${pattern}\\b`, "gi");
+      if (regex.test(lower)) {
+        reversalCount += 1;
+        break;
+      }
+    }
+  }
+  const baseScore = reversalCount / assistantMessages.length * 50;
+  const lateReversals = assistantMessages.slice(-Math.ceil(assistantMessages.length / 3));
+  const lateReversalCount = lateReversals.filter((m) => {
+    const lower = m.content.toLowerCase();
+    return HEDGING_PATTERNS.negationPatterns.some((p) => new RegExp(`\\b${p}\\b`, "i").test(lower));
+  }).length;
+  const lateBonus = lateReversalCount / Math.max(lateReversals.length, 1) * 30;
+  return Math.min(100, Math.round(baseScore + lateBonus));
+}
+function calculateConfidenceDrift(messages) {
+  if (messages.length < 2) return 0;
+  const hedgingScore = messages.filter((m) => m.role === "assistant").reduce((sum, m) => sum + detectHedgingLanguage(m.content), 0) / Math.max(messages.filter((m) => m.role === "assistant").length, 1);
+  const trendScore = trackConfidenceTrend(messages);
+  const reversalScore = detectNegationReversals(messages);
+  const composite = Math.round(
+    hedgingScore * 0.4 + trendScore * 0.35 + reversalScore * 0.25
+  );
+  return Math.min(100, composite);
+}
+var HEDGING_PATTERNS;
+var init_confidence_analyzer = __esm({
+  "src/core/confidence-analyzer.ts"() {
+    "use strict";
+    HEDGING_PATTERNS = {
+      // Modal verbs + uncertainty
+      modalUncertainty: [
+        "might",
+        "may",
+        "could",
+        "could be",
+        "appears to be",
+        "seems to be",
+        "appears",
+        "seems",
+        "possibly",
+        "arguably",
+        "allegedly"
+      ],
+      // Adverbs of uncertainty
+      uncertainAdverbs: [
+        "probably",
+        "likely",
+        "perhaps",
+        "maybe",
+        "somewhat",
+        "relatively",
+        "quite",
+        "fairly",
+        "rather",
+        "approximately",
+        "roughly",
+        "sort of",
+        "kind of",
+        "a bit",
+        "a little"
+      ],
+      // Epistemic markers (subjective speech)
+      epistemicMarkers: [
+        "I think",
+        "I believe",
+        "in my opinion",
+        "in my view",
+        "it seems",
+        "it appears",
+        "I would say",
+        "I'd say"
+      ],
+      // Downgraders (reduce force of statement)
+      downgraders: [
+        "just",
+        "only",
+        "merely",
+        "simply",
+        "barely",
+        "scarcely",
+        "somewhat",
+        "not quite",
+        "not entirely",
+        "not fully"
+      ],
+      // Negation reversals (contradicting prior claims)
+      negationPatterns: [
+        "actually",
+        "wait",
+        "hold on",
+        "correction",
+        "let me correct",
+        "upon reflection",
+        "on second thought",
+        "rethinking",
+        "mistake",
+        "I was wrong",
+        "I apologize",
+        "I retract"
+      ]
+    };
+  }
+});
+
+// src/core/drift-calculator.ts
+function calculateDrift(messages, weights = DEFAULT_WEIGHTS, userGoal) {
+  if (messages.length === 0) {
+    return emptyAnalysis(weights);
+  }
+  messages = messages.slice().sort((a, b) => (a.timestamp || 0) - (b.timestamp || 0));
+  for (let i = 1; i < messages.length; i++) {
+    if ((messages[i].timestamp || 0) < (messages[i - 1].timestamp || 0)) {
+      console.warn("[driftcli] Non-monotonic timestamps detected after sort \u2014 possible clock skew or corrupted session file");
+      break;
+    }
+  }
+  const factors = {
+    contextSaturation: calcMessageDecay(messages),
+    topicScatter: calculateTopicEntropy(messages),
+    uncertaintySignals: calcContradictionScore(messages),
+    codeInconsistency: calcCodeInconsistency(messages),
+    repetition: calcRepetition(messages),
+    goalDistance: calculateAnchorDrift(messages, userGoal),
+    confidenceDrift: calculateConfidenceDrift(messages)
+  };
+  const score = Math.min(100, Math.max(0, Math.round(
+    factors.contextSaturation * weights.contextSaturation + factors.topicScatter * weights.topicScatter + factors.uncertaintySignals * weights.uncertaintySignals + factors.codeInconsistency * weights.codeInconsistency + factors.repetition * weights.repetition + factors.goalDistance * weights.goalDistance + factors.confidenceDrift * weights.confidenceDrift
+  )));
+  const level = scoreToLevel(score);
+  const sessionDuration = messages[messages.length - 1].timestamp - messages[0].timestamp;
+  const goalDrift = calculateGoalDriftCheckpoints(messages, userGoal);
+  return {
+    score,
+    level,
+    factors,
+    weights,
+    messageCount: messages.length,
+    sessionDuration,
+    recommendations: generateRecommendations(score, factors),
+    calculatedAt: Date.now(),
+    goalDrift
+  };
+}
+function calcMessageDecay(messages) {
+  let totalTokens = 0;
+  for (const msg of messages) {
+    const words = msg.content.split(/\s+/).filter((w) => w.length > 0).length;
+    const hasCode = msg.content.includes("```");
+    const tokenEstimate = Math.round(words * 1.3 * (hasCode ? 1.5 : 1));
+    totalTokens += tokenEstimate;
+  }
+  if (totalTokens < 500) return 0;
+  let score = Math.min(100, Math.round(15 * Math.log(totalTokens / 1500)));
+  if (score < 0) score = 0;
+  if (messages.length > 50) score += 10;
+  else if (messages.length > 25) score += 5;
+  const readabilityPenalty = calcReadabilityDecay(messages);
+  score += readabilityPenalty;
+  return Math.min(100, score);
+}
+function calcReadabilityDecay(messages) {
+  const assistantMsgs = messages.filter((m) => m.role === "assistant" && m.content.length > 50);
+  if (assistantMsgs.length < 4) return 0;
+  const quarter = Math.max(2, Math.floor(assistantMsgs.length / 4));
+  const earlyMsgs = assistantMsgs.slice(0, quarter);
+  const lateMsgs = assistantMsgs.slice(-quarter);
+  const earlyGrade = earlyMsgs.reduce((sum, m) => sum + fleschKincaidGrade(m.content), 0) / earlyMsgs.length;
+  const lateGrade = lateMsgs.reduce((sum, m) => sum + fleschKincaidGrade(m.content), 0) / lateMsgs.length;
+  const drop = earlyGrade - lateGrade;
+  if (drop < 2) return 0;
+  if (drop < 4) return 5;
+  if (drop < 6) return 10;
+  return 15;
+}
+function calcContradictionScore(messages) {
+  const assistantMessages = messages.filter((m) => m.role === "assistant");
+  if (assistantMessages.length === 0) return 0;
+  const totalContradictions = countContradictions(assistantMessages);
+  const score = Math.min(100, totalContradictions / 5 * 80);
+  return Math.round(score);
+}
+function calcCodeInconsistency(messages) {
+  const codeBlocks = extractCodeBlocks(messages);
+  if (codeBlocks.length < 2) return 0;
+  const languages = new Set(
+    codeBlocks.map((b) => b.language).filter((l) => l !== "unknown")
+  );
+  if (languages.size <= 1) return 0;
+  const score = Math.min(100, Math.round(15 + (languages.size - 1) * 20));
+  return score;
+}
+function calcRepetition(messages) {
+  if (messages.length < 8) return 0;
+  const assistantMsgs = messages.filter((m) => m.role === "assistant").slice(-25);
+  if (assistantMsgs.length < 4) return 0;
+  const WINDOW = 4;
+  const repetitionRates = [];
+  for (let i = 3; i < assistantMsgs.length; i++) {
+    const current = extractNgrams(assistantMsgs[i].content, 3);
+    if (current.size < 3) continue;
+    const pool = /* @__PURE__ */ new Set();
+    for (let j = Math.max(0, i - WINDOW); j < i; j++) {
+      for (const gram of extractNgrams(assistantMsgs[j].content, 3)) {
+        pool.add(gram);
+      }
+    }
+    let repeated = 0;
+    for (const gram of current) {
+      if (pool.has(gram)) repeated++;
+    }
+    const rate = repeated / current.size;
+    repetitionRates.push(rate);
+  }
+  let codeScore = 0;
+  const codeBlocksByMsg = assistantMsgs.map((m) => {
+    return [...m.content.matchAll(/```\w*\n([\s\S]*?)```/g)].map((match) => match[1].replace(/\s+/g, " ").trim());
+  });
+  for (let i = 0; i < codeBlocksByMsg.length; i++) {
+    for (let j = i + 2; j < Math.min(codeBlocksByMsg.length, i + WINDOW + 1); j++) {
+      for (const blockA of codeBlocksByMsg[i]) {
+        if (blockA.length < 20) continue;
+        for (const blockB of codeBlocksByMsg[j]) {
+          if (blockB.length < 20) continue;
+          if (charSimilarity(blockA, blockB) > 0.8) codeScore += 25;
+        }
+      }
+    }
+  }
+  if (repetitionRates.length === 0) return Math.min(100, codeScore);
+  let weightedSum = 0;
+  let totalWeight = 0;
+  for (let i = 0; i < repetitionRates.length; i++) {
+    const w = i + 1;
+    weightedSum += repetitionRates[i] * w;
+    totalWeight += w;
+  }
+  const avgRate = weightedSum / totalWeight;
+  let textScore = 0;
+  if (avgRate >= 0.6) {
+    textScore = Math.round(80 + Math.min(20, (avgRate - 0.6) / 0.4 * 20));
+  } else if (avgRate >= 0.35) {
+    textScore = Math.round(40 + (avgRate - 0.35) / 0.25 * 40);
+  } else if (avgRate >= 0.15) {
+    textScore = Math.round((avgRate - 0.15) / 0.2 * 40);
+  }
+  const finalScore = Math.min(100, textScore + codeScore);
+  return finalScore;
+}
+function charSimilarity(a, b) {
+  const maxLen = Math.max(a.length, b.length);
+  if (maxLen === 0) return 1;
+  if (a === b) return 1;
+  let positionalMatches = 0;
+  const minLen = Math.min(a.length, b.length);
+  for (let i = 0; i < minLen; i++) {
+    if (a[i] === b[i]) positionalMatches++;
+  }
+  const positionalScore = positionalMatches / maxLen;
+  const bigramsA = /* @__PURE__ */ new Map();
+  const bigramsB = /* @__PURE__ */ new Map();
+  for (let i = 0; i < a.length - 1; i++) {
+    const bg = a.slice(i, i + 2);
+    bigramsA.set(bg, (bigramsA.get(bg) || 0) + 1);
+  }
+  for (let i = 0; i < b.length - 1; i++) {
+    const bg = b.slice(i, i + 2);
+    bigramsB.set(bg, (bigramsB.get(bg) || 0) + 1);
+  }
+  let intersection = 0;
+  let union = 0;
+  const allBigrams = /* @__PURE__ */ new Set([...bigramsA.keys(), ...bigramsB.keys()]);
+  for (const bg of allBigrams) {
+    const countA = bigramsA.get(bg) || 0;
+    const countB = bigramsB.get(bg) || 0;
+    intersection += Math.min(countA, countB);
+    union += Math.max(countA, countB);
+  }
+  const bigramScore = union === 0 ? 1 : intersection / union;
+  return Math.max(positionalScore, bigramScore);
+}
+function extractCodeBlocks(messages) {
+  const blocks = [];
+  for (const msg of messages) {
+    for (const match of msg.content.matchAll(/```(\w*)\n([\s\S]*?)```/g)) {
+      const language = detectLanguage(match[1], match[2]);
+      blocks.push({ language, content: match[2] });
+    }
+  }
+  return blocks;
+}
+function detectLanguage(label, content) {
+  if (label) return label.toLowerCase();
+  if (content.includes("import React") || content.includes("useState")) return "jsx";
+  if (content.includes("def ") && content.includes(":")) return "python";
+  if (content.includes("func ") && content.includes("{")) return "go";
+  if (content.includes("fn ") && content.includes("->")) return "rust";
+  if (content.includes("function") || content.includes("const ")) return "javascript";
+  return "unknown";
+}
+function generateRecommendations(score, factors) {
+  const recs = [];
+  if (score <= 30) {
+    recs.push("Context is clean \u2014 carry on!");
+    return recs;
+  }
+  if (factors.contextSaturation > 50) {
+    recs.push("Long conversation \u2014 consider starting fresh with a summary of key decisions.");
+  }
+  if (factors.topicScatter > 50) {
+    recs.push("Multiple topics detected \u2014 try to keep one topic per conversation.");
+  }
+  if (factors.uncertaintySignals > 40) {
+    recs.push("AI is self-correcting frequently \u2014 context may be confused. Re-state your requirements.");
+  }
+  if (factors.codeInconsistency > 30) {
+    recs.push("Multiple languages/frameworks in one chat \u2014 start a new chat for each tech stack.");
+  }
+  if (factors.repetition > 30) {
+    recs.push("AI is repeating itself \u2014 context is degrading. Start a new conversation.");
+  }
+  if (factors.goalDistance > 50) {
+    recs.push("Conversation has drifted far from your original goal. Re-anchor or start fresh.");
+  }
+  if (factors.confidenceDrift > 40) {
+    recs.push("AI confidence is declining \u2014 context may be becoming unreliable. Verify assumptions.");
+  }
+  if (score > 80) {
+    recs.push("Strongly recommend starting a new conversation. Copy your key context first.");
+  }
+  return recs;
+}
+function emptyAnalysis(weights) {
+  return {
+    score: 0,
+    level: "fresh",
+    factors: {
+      contextSaturation: 0,
+      topicScatter: 0,
+      uncertaintySignals: 0,
+      codeInconsistency: 0,
+      repetition: 0,
+      goalDistance: 0,
+      confidenceDrift: 0
+    },
+    weights,
+    messageCount: 0,
+    sessionDuration: 0,
+    recommendations: ["No messages yet."],
+    calculatedAt: Date.now(),
+    goalDrift: {
+      checkpoints: [],
+      trajectory: "stable",
+      averageScore: 0,
+      startToEndDrift: 0
+    }
+  };
+}
+var init_drift_calculator = __esm({
+  "src/core/drift-calculator.ts"() {
+    "use strict";
+    init_types();
+    init_topic_analyzer();
+    init_contradiction_detector();
+    init_confidence_analyzer();
+  }
+});
+
+// src/config.ts
+function loadConfig() {
+  const homeDir = process.env.DRIFTCLI_HOME ?? os4.homedir();
+  const globalRaw = tryLoadJson(path4.join(homeDir, ".driftclirc")) ?? {};
+  const projectRaw = tryLoadJson(path4.join(process.cwd(), ".driftcli")) ?? {};
+  const warnThreshold = projectRaw.warnThreshold ?? globalRaw.warnThreshold ?? DEFAULT_CONFIG.warnThreshold;
+  const cacheTtlMs = projectRaw.sessionResolution?.cacheTtlMs ?? globalRaw.sessionResolution?.cacheTtlMs ?? DEFAULT_CONFIG.sessionResolution.cacheTtlMs;
+  const storageEnabled = projectRaw.storage?.enabled ?? globalRaw.storage?.enabled ?? DEFAULT_CONFIG.storage.enabled;
+  const storageDirectory = projectRaw.storage?.directory ?? globalRaw.storage?.directory;
+  const presetName = projectRaw.preset ?? globalRaw.preset;
+  let weights = { ...DEFAULT_WEIGHTS };
+  if (presetName !== void 0) {
+    const presetWeights = WEIGHT_PRESETS[presetName];
+    if (presetWeights) {
+      weights = { ...presetWeights };
+    } else {
+      console.warn(`[driftcli] Unknown preset "${presetName}" \u2014 using default weights`);
+    }
+  }
+  if (globalRaw.weights) {
+    weights = { ...weights, ...globalRaw.weights };
+  }
+  if (projectRaw.weights) {
+    weights = { ...weights, ...projectRaw.weights };
+  }
+  return {
+    weights,
+    preset: presetName,
+    warnThreshold,
+    sessionResolution: { cacheTtlMs },
+    storage: { enabled: storageEnabled, ...storageDirectory ? { directory: storageDirectory } : {} }
+  };
+}
+function tryLoadJson(filePath) {
+  try {
+    if (!fs4.existsSync(filePath)) return null;
+    const raw = fs4.readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch (err) {
+    console.warn(
+      `[driftcli] Could not load config from ${filePath}: ${err instanceof Error ? err.message : err}`
+    );
+    return null;
+  }
+}
+var fs4, path4, os4, WEIGHT_PRESETS, DEFAULT_CONFIG;
+var init_config = __esm({
+  "src/config.ts"() {
+    "use strict";
+    fs4 = __toESM(require("fs"));
+    path4 = __toESM(require("path"));
+    os4 = __toESM(require("os"));
+    init_types();
+    WEIGHT_PRESETS = {
+      /** Equal importance across all seven factors. */
+      strict: {
+        contextSaturation: 1 / 7,
+        topicScatter: 1 / 7,
+        uncertaintySignals: 1 / 7,
+        codeInconsistency: 1 / 7,
+        repetition: 1 / 7,
+        goalDistance: 1 / 7,
+        confidenceDrift: 1 / 7
+      },
+      /** Emphasises code consistency and repetition — good for focused coding sessions. */
+      coding: {
+        contextSaturation: 0.2,
+        topicScatter: 0.08,
+        uncertaintySignals: 0.1,
+        codeInconsistency: 0.22,
+        repetition: 0.25,
+        goalDistance: 0.1,
+        confidenceDrift: 0.05
+      },
+      /** Emphasises topic stability and goal alignment — good for research or planning. */
+      research: {
+        contextSaturation: 0.15,
+        topicScatter: 0.2,
+        uncertaintySignals: 0.15,
+        codeInconsistency: 0.05,
+        repetition: 0.15,
+        goalDistance: 0.25,
+        confidenceDrift: 0.05
+      },
+      /** Forgiving preset for brainstorming — topic scatter is not penalised heavily. */
+      brainstorm: {
+        contextSaturation: 0.25,
+        topicScatter: 0.05,
+        uncertaintySignals: 0.15,
+        codeInconsistency: 0.05,
+        repetition: 0.25,
+        goalDistance: 0.1,
+        confidenceDrift: 0.15
+      }
+    };
+    DEFAULT_CONFIG = {
+      weights: { ...DEFAULT_WEIGHTS },
+      warnThreshold: 60,
+      sessionResolution: {
+        cacheTtlMs: 5e3
+      },
+      storage: {
+        enabled: true
+      }
+    };
+  }
+});
+
+// src/storage.ts
+var fs5, path5, os5, Storage;
+var init_storage = __esm({
+  "src/storage.ts"() {
+    "use strict";
+    fs5 = __toESM(require("fs"));
+    path5 = __toESM(require("path"));
+    os5 = __toESM(require("os"));
+    Storage = class {
+      constructor(directory) {
+        this.dir = directory ?? path5.join(
+          process.env.DRIFTCLI_HOME ?? os5.homedir(),
+          ".driftcli",
+          "history"
+        );
+      }
+      /** Derive the storage path for a given session key. */
+      sessionPath(sessionKey) {
+        return path5.join(this.dir, `${sessionKey}.jsonl`);
+      }
+      /** Append a drift snapshot for a session. Creates the directory if needed. */
+      record(sessionKey, analysis) {
+        try {
+          if (!fs5.existsSync(this.dir)) {
+            fs5.mkdirSync(this.dir, { recursive: true });
+          }
+          const snapshot = {
+            score: analysis.score,
+            level: analysis.level,
+            factors: { ...analysis.factors },
+            messageCount: analysis.messageCount,
+            sessionDuration: analysis.sessionDuration,
+            calculatedAt: analysis.calculatedAt
+          };
+          fs5.appendFileSync(this.sessionPath(sessionKey), JSON.stringify(snapshot) + "\n", "utf-8");
+        } catch (err) {
+          console.warn(`[driftcli] Storage write failed: ${err instanceof Error ? err.message : err}`);
+        }
+      }
+      /** Read the last `limit` snapshots for a session. Returns [] if no history exists. */
+      getHistory(sessionKey, limit = 20) {
+        const filePath = this.sessionPath(sessionKey);
+        if (!fs5.existsSync(filePath)) return [];
+        try {
+          const snapshots = [];
+          const lines = fs5.readFileSync(filePath, "utf-8").split("\n").filter((l) => l.trim());
+          for (const line of lines) {
+            try {
+              snapshots.push(JSON.parse(line));
+            } catch {
+            }
+          }
+          return snapshots.slice(-limit);
+        } catch (err) {
+          console.warn(`[driftcli] Storage read failed: ${err instanceof Error ? err.message : err}`);
+          return [];
+        }
+      }
+      /** Delete history for a session (e.g. after a handoff/reset). */
+      clearHistory(sessionKey) {
+        const filePath = this.sessionPath(sessionKey);
+        try {
+          if (fs5.existsSync(filePath)) fs5.unlinkSync(filePath);
+        } catch (err) {
+          console.warn(`[driftcli] Storage clear failed: ${err instanceof Error ? err.message : err}`);
+        }
+      }
+    };
+  }
+});
+
+// src/ui.ts
+function levelColor(level) {
+  switch (level) {
+    case "fresh":
+      return C.green;
+    case "warming":
+      return C.yellow;
+    case "drifting":
+      return C.red;
+    case "polluted":
+      return C.dim;
+    default:
+      return C.reset;
+  }
+}
+function bar(score, width = 10) {
+  const filled = Math.min(width, Math.round(score / 100 * width));
+  return "\u2588".repeat(filled) + "\u2591".repeat(width - filled);
+}
+function trendArrow(cur, prev) {
+  if (prev === void 0) return " ";
+  if (cur - prev > 2) return "\u2197";
+  if (prev - cur > 2) return "\u2198";
+  return "\u2192";
+}
+function sparkline(scores) {
+  const CHARS = "\u2581\u2582\u2583\u2584\u2585\u2586\u2587\u2588";
+  return scores.map((s) => CHARS[Math.min(7, Math.floor(s / 12.5))]).join("");
+}
+function renderDashboard(analysis, prevFactors, sessionFile) {
+  const color = levelColor(analysis.level);
+  const emoji = LEVEL_EMOJI[analysis.level] ?? "\u2753";
+  const project = path6.basename(path6.dirname(sessionFile));
+  const time = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+  const sep = `${C.dim}${"\u2501".repeat(54)}${C.reset}`;
+  const lines = [
+    sep,
+    `  ${C.bold}DriftCLI${C.reset}  \u2022  ${project}  \u2022  ${time}`,
+    ``,
+    `  Score  ${color}${C.bold}${analysis.score}${C.reset} ${emoji} ${color}${analysis.level.toUpperCase()}${C.reset}    Messages  ${analysis.messageCount}`,
+    ``
+  ];
+  for (const [key, val] of Object.entries(analysis.factors)) {
+    const prev = prevFactors?.[key];
+    const arrow = trendArrow(val, prev);
+    const label = (FACTOR_LABELS[key] ?? key).padEnd(20);
+    const barStr = `${color}${bar(val)}${C.reset}`;
+    const valStr = String(Math.round(val)).padStart(3);
+    lines.push(`  ${label} ${barStr}  ${valStr}  ${arrow}`);
+  }
+  lines.push(sep);
+  return lines.join("\n");
+}
+function renderTrend(snapshots) {
+  if (snapshots.length === 0) {
+    return "No drift history recorded yet.\nTip: Call get_drift() a few times to build up trend data.";
+  }
+  const scores = snapshots.map((s) => s.score);
+  const first = scores[0];
+  const last = scores[scores.length - 1];
+  const peak = Math.max(...scores);
+  const peakSnap = snapshots[scores.indexOf(peak)];
+  const avg = Math.round(scores.reduce((a, b) => a + b, 0) / scores.length);
+  const delta = last - first;
+  let trendLabel;
+  if (delta > 15) trendLabel = "\u2197 rising";
+  else if (delta < -15) trendLabel = "\u2198 falling";
+  else trendLabel = "\u2192 stable";
+  const scoreSeq = scores.length <= 10 ? scores.join(" \u2192 ") : [...scores.slice(0, 3), "\u2026", ...scores.slice(-3)].join(" \u2192 ");
+  const peakEmoji = LEVEL_EMOJI[peakSnap.level] ?? "\u2753";
+  const latestEmoji = LEVEL_EMOJI[snapshots[snapshots.length - 1].level] ?? "\u2753";
+  const lines = [
+    `Drift Trend \u2014 last ${snapshots.length} snapshot${snapshots.length === 1 ? "" : "s"}`,
+    ``,
+    `  ${sparkline(scores)}`,
+    `  ${scoreSeq}`,
+    ``,
+    `  Trend:   ${trendLabel}  (${delta >= 0 ? "+" : ""}${delta} over ${snapshots.length} checks)`,
+    `  Peak:    ${peak} ${peakEmoji} ${peakSnap.level.toUpperCase()}`,
+    `  Average: ${avg}`,
+    `  Latest:  ${last} ${latestEmoji} ${snapshots[snapshots.length - 1].level.toUpperCase()}`
+  ];
+  if (last > 60) {
+    lines.push(``, `\u26A0\uFE0F  Drift is high. Consider calling get_handoff() to start fresh.`);
+  }
+  return lines.join("\n");
+}
+var path6, C, LEVEL_EMOJI, FACTOR_LABELS;
+var init_ui = __esm({
+  "src/ui.ts"() {
+    "use strict";
+    path6 = __toESM(require("path"));
+    C = {
+      green: "\x1B[32m",
+      yellow: "\x1B[33m",
+      red: "\x1B[31m",
+      dim: "\x1B[90m",
+      bold: "\x1B[1m",
+      reset: "\x1B[0m"
+    };
+    LEVEL_EMOJI = {
+      fresh: "\u{1F7E2}",
+      warming: "\u{1F7E1}",
+      drifting: "\u{1F534}",
+      polluted: "\u26AB"
+    };
+    FACTOR_LABELS = {
+      contextSaturation: "Context Saturation",
+      topicScatter: "Topic Scatter",
+      uncertaintySignals: "Uncertainty",
+      codeInconsistency: "Code Inconsistency",
+      repetition: "Repetition",
+      goalDistance: "Goal Distance",
+      confidenceDrift: "Confidence Drift"
+    };
+  }
+});
+
+// src/cli.ts
+var cli_exports = {};
+__export(cli_exports, {
+  run: () => run
+});
+function run() {
+  const config2 = loadConfig();
+  const resolver2 = new SessionResolver(config2.sessionResolution.cacheTtlMs);
+  const storage2 = config2.storage.enabled ? new Storage(config2.storage.directory) : null;
+  const sessionFile = resolver2.resolve();
+  if (!sessionFile) {
+    console.error("No Claude Code session files found in ~/.claude/projects/");
+    console.error("Tip: set DRIFTCLI_SESSION_ID=<uuid> to pin a specific session.");
+    process.exit(1);
+  }
+  process.stdout.write("\x1B[2J\x1B[H");
+  let lastMessageCount = 0;
+  let prevFactors;
+  function check() {
+    const file = resolver2.resolve();
+    if (!file) return;
+    try {
+      const messages = resolver2.getAdapter(file).parse(file);
+      if (messages.length === lastMessageCount) return;
+      lastMessageCount = messages.length;
+      if (messages.length < 2) return;
+      const chatMessages = messages.map((m) => ({
+        ...m,
+        platform: "claude",
+        tabId: 0,
+        chatId: "cli"
+      }));
+      const analysis = calculateDrift(chatMessages, config2.weights);
+      const level = analysis.level;
+      const emoji = LEVEL_EMOJI[level] ?? "\u2753";
+      process.stdout.write(`\x1B]0;${emoji} ${analysis.score} \u2013 DriftCLI\x07`);
+      process.stdout.write("\x1B[H");
+      process.stdout.write(renderDashboard(analysis, prevFactors, file) + "\n");
+      prevFactors = { ...analysis.factors };
+      if (storage2) {
+        const sessionKey = path7.basename(file, ".jsonl");
+        storage2.record(sessionKey, analysis);
+      }
+    } catch (err) {
+    }
+  }
+  check();
+  setInterval(check, 3e3);
+}
+var path7;
+var init_cli = __esm({
+  "src/cli.ts"() {
+    "use strict";
+    path7 = __toESM(require("path"));
+    init_session_resolver();
+    init_drift_calculator();
+    init_config();
+    init_storage();
+    init_ui();
+  }
+});
+
+// src/mcp-server.ts
+var mcp_server_exports = {};
+__export(mcp_server_exports, {
+  main: () => main
+});
+function buildHandoff(analysis, messages, chatMessages, emoji, level) {
+  const durationMs = analysis.sessionDuration;
+  const durationMin = durationMs > 0 ? Math.round(durationMs / 6e4) : null;
+  const durationStr = durationMin !== null ? durationMin >= 60 ? `${Math.floor(durationMin / 60)}h ${durationMin % 60}m` : `${durationMin}m` : "unknown duration";
+  const topTerms = extractTopTerms(chatMessages, 6);
+  const topicsStr = topTerms.length > 0 ? topTerms.join(", ") : "not enough content to determine";
+  const recentUserMessages = messages.filter((m) => m.role === "user").slice(-3).map((m, i) => `${i + 1}. ${m.content.slice(0, 200)}${m.content.length > 200 ? "\u2026" : ""}`).join("\n");
+  let lastCodeSnippet = "";
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const match = [...messages[i].content.matchAll(/```(\w*)\n([\s\S]*?)```/g)].pop();
+    if (match) {
+      const lang = match[1] || "";
+      const code = match[2].split("\n").slice(0, 20).join("\n");
+      lastCodeSnippet = `\`\`\`${lang}
+${code}
+\`\`\``;
+      break;
+    }
+  }
+  const lines = [
+    `## Context Handoff`,
+    ``,
+    `**Drift:** ${analysis.score}/100 ${emoji} ${level.toUpperCase()} | **Messages:** ${messages.length} | **Duration:** ${durationStr}`,
+    ``,
+    `**Top topics:** ${topicsStr}`,
+    ``,
+    `**Recent focus (last 3 user messages):**`,
+    recentUserMessages
+  ];
+  if (lastCodeSnippet) {
+    lines.push(``, `**Last code context:**`, lastCodeSnippet);
+  }
+  lines.push(
+    ``,
+    `---`,
+    `*Paste the section below into your new session to restore context.*`,
+    ``,
+    `**Continuing from a previous session** (drift was ${analysis.score}/100, ${messages.length} messages, ${durationStr}).`,
+    `Main topics: ${topicsStr}.`,
+    ``,
+    `Recent questions:`,
+    recentUserMessages,
+    ``,
+    `Please continue from here.`
+  );
+  return lines.join("\n");
+}
+async function main() {
+  const transport = new import_stdio.StdioServerTransport();
+  await server.connect(transport);
+}
+var path8, import_server, import_stdio, import_types3, config, resolver, storage, server, LEVEL_EMOJI2;
+var init_mcp_server = __esm({
+  "src/mcp-server.ts"() {
+    "use strict";
+    path8 = __toESM(require("path"));
+    import_server = require("@modelcontextprotocol/sdk/server/index.js");
+    import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+    import_types3 = require("@modelcontextprotocol/sdk/types.js");
+    init_session_resolver();
+    init_drift_calculator();
+    init_types();
+    init_topic_analyzer();
+    init_config();
+    init_storage();
+    init_ui();
+    config = loadConfig();
+    resolver = new SessionResolver(config.sessionResolution.cacheTtlMs);
+    storage = config.storage.enabled ? new Storage(config.storage.directory) : null;
+    server = new import_server.Server(
+      { name: "driftcli", version: "0.1.0" },
+      { capabilities: { tools: {} } }
+    );
+    server.setRequestHandler(import_types3.ListToolsRequestSchema, async () => ({
+      tools: [
+        {
+          name: "get_drift",
+          description: "Returns the current drift score and factor breakdown for the active Claude Code session. Call this to check if the conversation context is degrading.",
+          inputSchema: { type: "object", properties: {} }
+        },
+        {
+          name: "get_handoff",
+          description: "Generates a handoff prompt summarizing the current session state. Use this when drift score is high (>60) to help start a fresh context.",
+          inputSchema: { type: "object", properties: {} }
+        },
+        {
+          name: "get_trend",
+          description: "Returns the drift history trend for the current session. Shows sparkline, score sequence, peak, average, and trajectory.",
+          inputSchema: { type: "object", properties: {} }
+        }
+      ]
+    }));
+    LEVEL_EMOJI2 = {
+      fresh: "\u{1F7E2}",
+      warming: "\u{1F7E1}",
+      drifting: "\u{1F534}",
+      polluted: "\u26AB"
+    };
+    server.setRequestHandler(import_types3.CallToolRequestSchema, async (request) => {
+      let sessionFile;
+      try {
+        sessionFile = resolver.resolve();
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error finding session: ${err instanceof Error ? err.message : err}` }] };
+      }
+      if (!sessionFile) {
+        return { content: [{ type: "text", text: "No active Claude Code session found." }] };
+      }
+      const adapter = resolver.getAdapter(sessionFile);
+      let messages;
+      try {
+        messages = adapter.parse(sessionFile);
+      } catch (err) {
+        return { content: [{ type: "text", text: `Error reading session file: ${err instanceof Error ? err.message : err}` }] };
+      }
+      if (messages.length < 2) {
+        return { content: [{ type: "text", text: "Not enough messages to calculate drift yet." }] };
+      }
+      const chatMessages = messages.map((m) => ({
+        ...m,
+        platform: "claude",
+        tabId: 0,
+        chatId: "cli"
+      }));
+      const analysis = calculateDrift(chatMessages, config.weights);
+      const level = scoreToLevel(analysis.score);
+      const emoji = LEVEL_EMOJI2[level] ?? "\u2753";
+      const adapterTag = adapter.name !== "claude" ? ` (${adapter.name})` : "";
+      if (request.params.name === "get_drift") {
+        let trendLine = "";
+        if (storage) {
+          const sessionKey = path8.basename(sessionFile, ".jsonl");
+          storage.record(sessionKey, analysis);
+          const snapshots = storage.getHistory(sessionKey, 10);
+          if (snapshots.length >= 3) {
+            const scores = snapshots.map((s) => s.score);
+            const delta = scores[scores.length - 1] - scores[0];
+            const arrow = delta > 10 ? "\u2197" : delta < -10 ? "\u2198" : "\u2192";
+            const sign = delta >= 0 ? "+" : "";
+            trendLine = `Trend (last ${scores.length}): ${sparkline(scores)}  ${sign}${delta} over ${scores.length} checks ${arrow}`;
+          }
+        }
+        const factors = Object.entries(analysis.factors).map(([k, v]) => `  ${k}: ${v.toFixed(1)}`).join("\n");
+        const isDegrading = analysis.score > config.warnThreshold;
+        const lines = [
+          `Drift Score: ${analysis.score} ${emoji} ${level.toUpperCase()}${adapterTag}`,
+          `Messages: ${messages.length}`,
+          ``,
+          `Factor breakdown:`,
+          factors,
+          ``,
+          isDegrading ? `\u26A0\uFE0F Context is degrading.` : `Context is healthy.`
+        ];
+        if (trendLine) lines.push(``, trendLine);
+        if (isDegrading) {
+          lines.push(
+            ``,
+            `---`,
+            buildHandoff(analysis, messages, chatMessages, emoji, level)
+          );
+        }
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+      }
+      if (request.params.name === "get_handoff") {
+        return { content: [{ type: "text", text: buildHandoff(analysis, messages, chatMessages, emoji, level) }] };
+      }
+      if (request.params.name === "get_trend") {
+        if (!storage) {
+          return {
+            content: [{
+              type: "text",
+              text: "Trend history is disabled.\nSet storage.enabled=true in ~/.driftclirc to activate it."
+            }]
+          };
+        }
+        const sessionKey = path8.basename(sessionFile, ".jsonl");
+        const snapshots = storage.getHistory(sessionKey);
+        return { content: [{ type: "text", text: renderTrend(snapshots) }] };
+      }
+      return { content: [{ type: "text", text: "Unknown tool." }] };
+    });
+  }
+});
+
+// src/bin.ts
+var command = process.argv[2];
+if (command === "watch") {
+  const { run: run2 } = (init_cli(), __toCommonJS(cli_exports));
+  run2();
+} else {
+  const { main: main2 } = (init_mcp_server(), __toCommonJS(mcp_server_exports));
+  main2().catch(console.error);
+}