@stackmemoryai/stackmemory 1.12.0 → 1.14.0

package/dist/src/core/models/model-router.js

@@ -38,7 +38,15 @@ const MODEL_TOKEN_LIMITS = {
   "THUDM/glm-4-9b-chat": 128e3,
   // Moonshot (Kimi)
   "kimi-k2.6": 256e3,
-  "kimi-k2.5": 256e3
+  "kimi-k2.5": 256e3,
+  // xAI (Grok)
+  "grok-4.1-fast": 131072,
+  "grok-4.3": 131072,
+  "grok-4": 131072,
+  // DeepSeek
+  "deepseek-v4-flash": 131072,
+  "deepseek-v4": 131072,
+  "deepseek-v4-pro": 131072
 };
 const DEFAULT_MODEL_TOKEN_LIMIT = 2e5;
 function getModelTokenLimit(model) {
@@ -100,6 +108,18 @@ const DEFAULT_CONFIG = {
       baseUrl: "https://api.moonshot.ai/v1",
       apiKeyEnv: "MOONSHOT_API_KEY"
     },
+    xai: {
+      provider: "xai",
+      model: "grok-4.1-fast",
+      baseUrl: "https://api.x.ai/v1",
+      apiKeyEnv: "XAI_API_KEY"
+    },
+    deepseek: {
+      provider: "deepseek",
+      model: "deepseek-v4-flash",
+      baseUrl: "https://api.deepseek.com/v1",
+      apiKeyEnv: "DEEPSEEK_API_KEY"
+    },
     "anthropic-batch": {
       provider: "anthropic-batch",
       model: "claude-sonnet-4-5-20250929",
@@ -251,6 +271,18 @@ const FALLBACK_CHAIN = [
   "anthropic"
 ];
 const CHEAP_PROVIDERS = [
+  {
+    provider: "deepseek",
+    model: "deepseek-v4-flash",
+    apiKeyEnv: "DEEPSEEK_API_KEY",
+    baseUrl: "https://api.deepseek.com/v1"
+  },
+  {
+    provider: "xai",
+    model: "grok-4.1-fast",
+    apiKeyEnv: "XAI_API_KEY",
+    baseUrl: "https://api.x.ai/v1"
+  },
   {
     provider: "moonshot",
     model: "kimi-k2.6",

package/dist/src/core/models/provider-pricing.js

@@ -3,7 +3,28 @@ import { dirname as __pathDirname } from 'path';
 const __filename = __fileURLToPath(import.meta.url);
 const __dirname = __pathDirname(__filename);
 const MODEL_PRICING = {
-  // Anthropic (direct API)
+  // Anthropic (direct API) — Opus 4.x share one price; 1M context, no
+  // long-context premium. Sourced platform.claude.com 2026-05-26.
+  "anthropic/claude-opus-4-8": {
+    inputPer1M: 5,
+    outputPer1M: 25,
+    source: "platform.claude.com"
+  },
+  "anthropic/claude-opus-4-7": {
+    inputPer1M: 5,
+    outputPer1M: 25,
+    source: "platform.claude.com"
+  },
+  "anthropic/claude-opus-4-6": {
+    inputPer1M: 5,
+    outputPer1M: 25,
+    source: "platform.claude.com"
+  },
+  "anthropic/claude-sonnet-4-6": {
+    inputPer1M: 3,
+    outputPer1M: 15,
+    source: "platform.claude.com"
+  },
   "anthropic/claude-sonnet-4-5-20250929": {
     inputPer1M: 3,
     outputPer1M: 15,
@@ -15,9 +36,9 @@ const MODEL_PRICING = {
     source: "anthropic.com"
   },
   "anthropic/claude-haiku-4-5-20251001": {
-    inputPer1M: 0.8,
-    outputPer1M: 4,
-    source: "anthropic.com"
+    inputPer1M: 1,
+    outputPer1M: 5,
+    source: "platform.claude.com"
   },
   // OpenAI (direct API)
   "openai/gpt-4o": {
@@ -56,8 +77,41 @@ function formatCost(usd) {
   if (usd < 0.01) return `$${usd.toFixed(6)}`;
   return `$${usd.toFixed(4)}`;
 }
+const MAX_PLAN_DISCOUNT_RAMP = {
+  start: process.env.STACKMEMORY_COST_RAMP_START ?? "2026-06-06",
+  end: process.env.STACKMEMORY_COST_RAMP_END ?? "2026-09-06",
+  startMultiplier: Number(
+    process.env.STACKMEMORY_COST_RAMP_START_MULTIPLIER ?? "0.2"
+  ),
+  endMultiplier: 1
+};
+function effectiveSpendMultiplier(date = /* @__PURE__ */ new Date(), ramp = MAX_PLAN_DISCOUNT_RAMP) {
+  const start = Date.parse(ramp.start);
+  const end = Date.parse(ramp.end);
+  const now = date.getTime();
+  if (!Number.isFinite(start) || !Number.isFinite(end) || end <= start) {
+    return ramp.endMultiplier;
+  }
+  if (now <= start) return ramp.startMultiplier;
+  if (now >= end) return ramp.endMultiplier;
+  const progress = (now - start) / (end - start);
+  return ramp.startMultiplier + progress * (ramp.endMultiplier - ramp.startMultiplier);
+}
+function effectiveCost(provider, model, inputTokens, outputTokens, date = /* @__PURE__ */ new Date()) {
+  const list = calculateCost(provider, model, inputTokens, outputTokens);
+  if (!list) return null;
+  const multiplier = effectiveSpendMultiplier(date);
+  return {
+    listCost: list.totalCost,
+    effectiveCost: list.totalCost * multiplier,
+    multiplier
+  };
+}
 export {
+  MAX_PLAN_DISCOUNT_RAMP,
   MODEL_PRICING,
   calculateCost,
+  effectiveCost,
+  effectiveSpendMultiplier,
   formatCost
 };

package/dist/src/core/patterns/index.js

@@ -0,0 +1,22 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import {
+  computeConfidence,
+  CONFIDENCE_DECAY_PER_WEEK,
+  CONFIDENCE_BOOST_PER_OBSERVATION,
+  CONFIDENCE_PENALTY_PER_CONTRADICTION
+} from "./types.js";
+import { PatternStore } from "./pattern-store.js";
+import { PatternObserver } from "./pattern-observer.js";
+import { PatternApplier } from "./pattern-applier.js";
+export {
+  CONFIDENCE_BOOST_PER_OBSERVATION,
+  CONFIDENCE_DECAY_PER_WEEK,
+  CONFIDENCE_PENALTY_PER_CONTRADICTION,
+  PatternApplier,
+  PatternObserver,
+  PatternStore,
+  computeConfidence
+};

package/dist/src/core/patterns/pattern-applier.js

@@ -0,0 +1,39 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+class PatternApplier {
+  constructor(store) {
+    this.store = store;
+  }
+  /**
+   * Find and format patterns relevant to a task.
+   * Returns a markdown block to inject into context.
+   */
+  apply(taskDescription, projectId) {
+    const patterns = this.store.search(taskDescription, projectId);
+    if (patterns.length === 0) return "";
+    for (const p of patterns) {
+      this.store.recordMatch(p.id);
+    }
+    const lines = ["## Learned Patterns", ""];
+    for (const p of patterns) {
+      const bar = this.confidenceBar(p.confidence);
+      lines.push(
+        `- ${bar} **${p.trigger}** \u2192 ${p.action} _(${p.domain}, ${p.observationCount} obs)_`
+      );
+    }
+    return lines.join("\n");
+  }
+  /** Get patterns as structured data (for MCP tool) */
+  query(taskDescription, projectId) {
+    return this.store.search(taskDescription, projectId);
+  }
+  confidenceBar(confidence) {
+    const filled = Math.round(confidence * 5);
+    return "\u2588".repeat(filled) + "\u2591".repeat(5 - filled);
+  }
+}
+export {
+  PatternApplier
+};

package/dist/src/core/patterns/pattern-observer.js

@@ -0,0 +1,157 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+class PatternObserver {
+  constructor(store) {
+    this.store = store;
+  }
+  /**
+   * Analyze a session's trace events and extract patterns.
+   * Call at session_end with the session's trace events.
+   */
+  observe(events, projectId) {
+    if (events.length < 3) return [];
+    const learned = [];
+    const sequences = this.findRepeatedSequences(events);
+    for (const seq of sequences) {
+      const id = this.sequenceId(seq.operations);
+      const existing = this.store.get(id);
+      if (existing) {
+        this.store.reinforce(id, `Session observation (${seq.count}x)`);
+      } else {
+        this.store.create({
+          id,
+          domain: this.inferDomain(seq.operations),
+          trigger: `When performing a ${this.describeIntent(seq.operations)} workflow`,
+          action: `Follow sequence: ${seq.operations.join(" \u2192 ")}`,
+          evidence: [`Observed ${seq.count}x in session`],
+          scope: projectId ? "project" : "global",
+          projectId,
+          source: "observed"
+        });
+      }
+      learned.push(id);
+    }
+    const errorFixes = this.findErrorFixPairs(events);
+    for (const { error, fix } of errorFixes) {
+      const id = `fix-${this.slugify(error.operation)}-${this.slugify(fix.operation)}`;
+      const existing = this.store.get(id);
+      if (existing) {
+        this.store.reinforce(
+          id,
+          `Error\u2192fix: ${error.error} \u2192 ${fix.operation}`
+        );
+      } else {
+        this.store.create({
+          id,
+          domain: "debugging",
+          trigger: `When encountering error in ${error.operation}`,
+          action: `Resolve with ${fix.operation}: ${this.summarizeInputs(fix)}`,
+          evidence: [`Error: ${error.error?.slice(0, 200)}`],
+          scope: projectId ? "project" : "global",
+          projectId,
+          source: "observed"
+        });
+      }
+      learned.push(id);
+    }
+    const preferences = this.findToolPreferences(events);
+    for (const { before, after, count } of preferences) {
+      const id = `prefer-${this.slugify(before)}-before-${this.slugify(after)}`;
+      const existing = this.store.get(id);
+      if (existing) {
+        this.store.reinforce(id, `${before}\u2192${after} (${count}x)`);
+      } else if (count >= 3) {
+        this.store.create({
+          id,
+          domain: "workflow",
+          trigger: `When about to use ${after}`,
+          action: `Use ${before} first`,
+          evidence: [`Observed ${count}x: ${before} always precedes ${after}`],
+          scope: "global",
+          source: "observed"
+        });
+        learned.push(id);
+      }
+    }
+    return learned;
+  }
+  // ── Sequence Detection ────────────────────────────────
+  findRepeatedSequences(events) {
+    const ops = events.map((e) => e.operation);
+    const sequences = /* @__PURE__ */ new Map();
+    for (let windowSize = 2; windowSize <= 4; windowSize++) {
+      for (let i = 0; i <= ops.length - windowSize; i++) {
+        const seq = ops.slice(i, i + windowSize);
+        const key = seq.join("\u2192");
+        const existing = sequences.get(key);
+        if (existing) {
+          existing.count++;
+        } else {
+          sequences.set(key, { operations: seq, count: 1 });
+        }
+      }
+    }
+    return Array.from(sequences.values()).filter((s) => s.count >= 3);
+  }
+  // ── Error→Fix Detection ───────────────────────────────
+  findErrorFixPairs(events) {
+    const pairs = [];
+    for (let i = 0; i < events.length - 1; i++) {
+      const event = events[i];
+      if (!event.error) continue;
+      for (let j = i + 1; j < Math.min(i + 4, events.length); j++) {
+        const next = events[j];
+        if (!next.error) {
+          pairs.push({ error: event, fix: next });
+          break;
+        }
+      }
+    }
+    return pairs;
+  }
+  // ── Tool Preference Detection ─────────────────────────
+  findToolPreferences(events) {
+    const pairs = /* @__PURE__ */ new Map();
+    const ops = events.map((e) => e.operation);
+    for (let i = 0; i < ops.length - 1; i++) {
+      const key = `${ops[i]}\u2192${ops[i + 1]}`;
+      pairs.set(key, (pairs.get(key) ?? 0) + 1);
+    }
+    return Array.from(pairs.entries()).filter(([, count]) => count >= 3).map(([key, count]) => {
+      const [before, after] = key.split("\u2192");
+      return { before, after, count };
+    });
+  }
+  // ── Helpers ───────────────────────────────────────────
+  sequenceId(ops) {
+    return `seq-${ops.map((o) => this.slugify(o)).join("-")}`;
+  }
+  slugify(s) {
+    return s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 30);
+  }
+  inferDomain(ops) {
+    const joined = ops.join(" ").toLowerCase();
+    if (/test|vitest|jest/.test(joined)) return "testing";
+    if (/git|commit|branch|push/.test(joined)) return "git";
+    if (/grep|glob|read|search/.test(joined)) return "workflow";
+    if (/edit|write/.test(joined)) return "code-style";
+    if (/security|auth|token/.test(joined)) return "security";
+    return "general";
+  }
+  describeIntent(ops) {
+    const unique = [...new Set(ops)];
+    if (unique.length <= 2) return unique.join(" + ");
+    return `${unique[0]} \u2192 ${unique[unique.length - 1]}`;
+  }
+  summarizeInputs(event) {
+    const inputs = event.inputs;
+    if (!inputs || typeof inputs !== "object") return "";
+    const keys = Object.keys(inputs).slice(0, 3);
+    return keys.join(", ");
+  }
+}
+export {
+  PatternObserver
+};

package/dist/src/core/patterns/pattern-store.js

@@ -0,0 +1,259 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import {
+  computeConfidence,
+  CONFIDENCE_DECAY_PER_WEEK,
+  CONFIDENCE_BOOST_PER_OBSERVATION
+} from "./types.js";
+class PatternStore {
+  constructor(db) {
+    this.db = db;
+  }
+  /** Create a new pattern */
+  create(input) {
+    const now = Date.now();
+    const confidence = input.confidence ?? computeConfidence(1);
+    this.db.prepare(
+      `
+      INSERT INTO patterns (id, domain, trigger, action, evidence, confidence, observation_count, scope, project_id, status, source, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `
+    ).run(
+      input.id,
+      input.domain,
+      input.trigger,
+      input.action,
+      JSON.stringify(input.evidence ?? []),
+      confidence,
+      1,
+      input.scope ?? "project",
+      input.projectId ?? null,
+      "pending",
+      input.source ?? "manual",
+      now,
+      now
+    );
+    return this.get(input.id);
+  }
+  /** Get a pattern by ID */
+  get(id) {
+    const row = this.db.prepare("SELECT * FROM patterns WHERE id = ?").get(id);
+    return row ? this.toPattern(row) : void 0;
+  }
+  /** List patterns with filtering */
+  list(query = {}) {
+    const conditions = [];
+    const params = [];
+    if (query.domain) {
+      conditions.push("domain = ?");
+      params.push(query.domain);
+    }
+    if (query.status) {
+      conditions.push("status = ?");
+      params.push(query.status);
+    }
+    if (query.scope) {
+      conditions.push("scope = ?");
+      params.push(query.scope);
+    }
+    if (query.projectId) {
+      conditions.push("(project_id = ? OR scope = 'global')");
+      params.push(query.projectId);
+    }
+    if (query.minConfidence !== void 0) {
+      conditions.push("confidence >= ?");
+      params.push(query.minConfidence);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const limit = query.limit ?? 100;
+    const rows = this.db.prepare(
+      `SELECT * FROM patterns ${where} ORDER BY confidence DESC, updated_at DESC LIMIT ?`
+    ).all(...params, limit);
+    return rows.map((r) => this.toPattern(r));
+  }
+  /** Record an observation that reinforces a pattern */
+  reinforce(id, evidence) {
+    const pattern = this.get(id);
+    if (!pattern) return;
+    const newCount = pattern.observationCount + 1;
+    const baseConfidence = computeConfidence(newCount);
+    const boosted = Math.min(
+      1,
+      baseConfidence + CONFIDENCE_BOOST_PER_OBSERVATION
+    );
+    const newEvidence = [...pattern.evidence, evidence].slice(-20);
+    this.db.prepare(
+      `
+      UPDATE patterns
+      SET observation_count = ?, confidence = ?, evidence = ?, updated_at = ?, status = CASE WHEN status = 'pending' AND ? >= 0.5 THEN 'active' ELSE status END
+      WHERE id = ?
+    `
+    ).run(
+      newCount,
+      boosted,
+      JSON.stringify(newEvidence),
+      Date.now(),
+      boosted,
+      id
+    );
+  }
+  /** Apply weekly confidence decay to all patterns */
+  applyDecay() {
+    const oneWeekAgo = Date.now() - 7 * 24 * 60 * 60 * 1e3;
+    const result = this.db.prepare(
+      `
+      UPDATE patterns
+      SET confidence = MAX(0.05, confidence - ?),
+          updated_at = ?
+      WHERE updated_at < ? AND status != 'archived'
+    `
+    ).run(CONFIDENCE_DECAY_PER_WEEK, Date.now(), oneWeekAgo);
+    return result.changes;
+  }
+  /** Mark a pattern as matched during retrieval */
+  recordMatch(id) {
+    this.db.prepare("UPDATE patterns SET last_matched_at = ? WHERE id = ?").run(Date.now(), id);
+  }
+  /** Activate a pending pattern */
+  activate(id) {
+    this.db.prepare(
+      "UPDATE patterns SET status = 'active', updated_at = ? WHERE id = ?"
+    ).run(Date.now(), id);
+  }
+  /** Archive a pattern */
+  archive(id, supersededBy) {
+    this.db.prepare(
+      "UPDATE patterns SET status = 'archived', superseded_by = ?, updated_at = ? WHERE id = ?"
+    ).run(supersededBy ?? null, Date.now(), id);
+  }
+  /** Prune old pending patterns that never got promoted */
+  prune(maxAgeDays = 30) {
+    const cutoff = Date.now() - maxAgeDays * 24 * 60 * 60 * 1e3;
+    const result = this.db.prepare(
+      "DELETE FROM patterns WHERE status = 'pending' AND created_at < ?"
+    ).run(cutoff);
+    return result.changes;
+  }
+  /** Get aggregate stats */
+  stats() {
+    const all = this.list({ limit: 1e3 });
+    const byDomain = {};
+    const byStatus = {};
+    let totalConfidence = 0;
+    for (const p of all) {
+      byDomain[p.domain] = (byDomain[p.domain] ?? 0) + 1;
+      byStatus[p.status] = (byStatus[p.status] ?? 0) + 1;
+      totalConfidence += p.confidence;
+    }
+    const topPatterns = all.filter((p) => p.status === "active").slice(0, 10).map((p) => ({ id: p.id, confidence: p.confidence, trigger: p.trigger }));
+    return {
+      total: all.length,
+      byDomain,
+      byStatus,
+      avgConfidence: all.length > 0 ? totalConfidence / all.length : 0,
+      topPatterns
+    };
+  }
+  /** Promote a project-scoped pattern to global */
+  promote(id) {
+    this.db.prepare(
+      "UPDATE patterns SET scope = 'global', project_id = NULL, updated_at = ? WHERE id = ?"
+    ).run(Date.now(), id);
+  }
+  /** List distinct project IDs with pattern counts */
+  projects() {
+    const rows = this.db.prepare(
+      `
+      SELECT project_id, COUNT(*) as count, AVG(confidence) as avg_confidence
+      FROM patterns
+      WHERE project_id IS NOT NULL AND status != 'archived'
+      GROUP BY project_id
+      ORDER BY count DESC
+    `
+    ).all();
+    return rows.map((r) => ({
+      projectId: r.project_id,
+      count: r.count,
+      avgConfidence: r.avg_confidence
+    }));
+  }
+  /** Find patterns that appear in 2+ projects (promotion candidates) */
+  promotionCandidates(minConfidence = 0.7) {
+    const rows = this.db.prepare(
+      `
+      SELECT p1.* FROM patterns p1
+      WHERE p1.scope = 'project'
+        AND p1.confidence >= ?
+        AND p1.status = 'active'
+        AND EXISTS (
+          SELECT 1 FROM patterns p2
+          WHERE p2.trigger = p1.trigger
+            AND p2.action = p1.action
+            AND p2.project_id != p1.project_id
+            AND p2.status = 'active'
+        )
+      ORDER BY p1.confidence DESC
+    `
+    ).all(minConfidence);
+    return rows.map((r) => this.toPattern(r));
+  }
+  /** Find clusters of related patterns (for evolve) */
+  findClusters(minSize = 2) {
+    const active = this.list({ status: "active", limit: 500 });
+    const byDomain = /* @__PURE__ */ new Map();
+    for (const p of active) {
+      const list = byDomain.get(p.domain) ?? [];
+      list.push(p);
+      byDomain.set(p.domain, list);
+    }
+    return Array.from(byDomain.entries()).filter(([, patterns]) => patterns.length >= minSize).map(([domain, patterns]) => ({
+      domain,
+      patterns: patterns.sort((a, b) => b.confidence - a.confidence)
+    }));
+  }
+  /** Find patterns relevant to a query string */
+  search(query, projectId) {
+    const words = query.toLowerCase().split(/\s+/).filter(Boolean);
+    if (words.length === 0) return [];
+    const candidates = this.list({
+      status: "active",
+      projectId,
+      minConfidence: 0.3,
+      limit: 200
+    });
+    const scored = candidates.map((p) => {
+      const text = `${p.trigger} ${p.action} ${p.domain}`.toLowerCase();
+      const hits = words.filter((w) => text.includes(w)).length;
+      const score = hits / words.length;
+      return { pattern: p, score };
+    });
+    return scored.filter((s) => s.score > 0.2).sort(
+      (a, b) => b.score * b.pattern.confidence - a.score * a.pattern.confidence
+    ).slice(0, 10).map((s) => s.pattern);
+  }
+  // ── Private ───────────────────────────────────────────
+  toPattern(row) {
+    return {
+      id: row.id,
+      domain: row.domain,
+      trigger: row.trigger,
+      action: row.action,
+      evidence: JSON.parse(row.evidence || "[]"),
+      confidence: row.confidence,
+      observationCount: row.observation_count,
+      scope: row.scope,
+      projectId: row.project_id,
+      status: row.status,
+      source: row.source,
+      createdAt: row.created_at,
+      updatedAt: row.updated_at,
+      lastMatchedAt: row.last_matched_at,
+      supersededBy: row.superseded_by
+    };
+  }
+}
+export {
+  PatternStore
+};

package/dist/src/core/patterns/types.js

@@ -0,0 +1,19 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+function computeConfidence(observationCount) {
+  if (observationCount >= 11) return 0.85;
+  if (observationCount >= 6) return 0.7;
+  if (observationCount >= 3) return 0.5;
+  return 0.3;
+}
+const CONFIDENCE_DECAY_PER_WEEK = 0.02;
+const CONFIDENCE_BOOST_PER_OBSERVATION = 0.05;
+const CONFIDENCE_PENALTY_PER_CONTRADICTION = 0.1;
+export {
+  CONFIDENCE_BOOST_PER_OBSERVATION,
+  CONFIDENCE_DECAY_PER_WEEK,
+  CONFIDENCE_PENALTY_PER_CONTRADICTION,
+  computeConfidence
+};

package/dist/src/core/retrieval/llm-context-retrieval.js

@@ -8,6 +8,7 @@ import {
   DEFAULT_RETRIEVAL_CONFIG
 } from "./types.js";
 import { logger } from "../monitoring/logger.js";
+import { estimateTokens } from "../cache/token-estimator.js";
 import { LazyContextLoader } from "../performance/lazy-context-loader.js";
 import { ContextCache } from "../performance/context-cache.js";
 import { createLLMProvider } from "./llm-provider.js";
@@ -113,11 +114,11 @@ class HeuristicAnalyzer {
     let tokens = 50;
     tokens += frame.eventCount * 30;
     tokens += frame.anchorCount * 40;
-    if (frame.digestPreview) tokens += frame.digestPreview.length / 4;
+    if (frame.digestPreview) tokens += estimateTokens(frame.digestPreview);
     return Math.floor(tokens);
   }
   estimateSummaryTokens(summary) {
-    return Math.floor(JSON.stringify(summary).length / 4);
+    return estimateTokens(JSON.stringify(summary));
   }
   assessQueryComplexity(query, parsedQuery) {
     const wordCount = query.split(/\s+/).length;
@@ -428,8 +429,8 @@ Respond with only the JSON object, no other text.`;
         })),
         metadata: {
           analysisTimeMs: 0,
-          summaryTokens: Math.floor(
-            JSON.stringify(request.compressedSummary).length / 4
+          summaryTokens: estimateTokens(
+            JSON.stringify(request.compressedSummary)
           ),
           queryComplexity: this.assessQueryComplexity(request.currentQuery),
           matchedPatterns: [],