lynkr 9.14.0 → 9.14.2

package/src/orchestrator/sse-transformer.js

@@ -158,7 +158,62 @@ async function* _openaiToAnthropicEvents(upstream, opts = {}) {
     }
   };
 
+  // GLM-family reasoning leak filter (streaming twin of the fix in
+  // convertOpenAIToAnthropic): suppresses matched <think>…</think> spans and
+  // strips a bare orphan closing tag from visible text deltas, holding back
+  // trailing partial-tag fragments so tags split across chunk boundaries
+  // still match. Orphan pre-text has already been emitted by the time the
+  // closer arrives — a stream can't retract — so only the tag is removed.
+  let _inThink = false;
+  let _tagTail = "";
+  const _partialTagLen = (s) => {
+    for (let k = Math.min(8, s.length); k > 0; k--) {
+      const suf = s.slice(-k);
+      if ("</think>".startsWith(suf) || "<think>".startsWith(suf)) return k;
+    }
+    return 0;
+  };
+  const filterThink = (text) => {
+    let s = _tagTail + text;
+    _tagTail = "";
+    let out = "";
+    for (;;) {
+      if (_inThink) {
+        const close = s.indexOf("</think>");
+        if (close === -1) break; // still inside thinking — discard s (tail kept below)
+        s = s.slice(close + 8);
+        _inThink = false;
+      } else {
+        const open = s.indexOf("<think>");
+        const close = s.indexOf("</think>");
+        if (close !== -1 && (open === -1 || close < open)) {
+          out += s.slice(0, close); // orphan closer: drop the tag only
+          s = s.slice(close + 8);
+        } else if (open !== -1) {
+          out += s.slice(0, open);
+          s = s.slice(open + 7);
+          _inThink = true;
+        } else {
+          break;
+        }
+      }
+    }
+    const keep = _partialTagLen(s);
+    if (keep > 0) _tagTail = s.slice(-keep);
+    if (!_inThink && s.length > keep) out += s.slice(0, s.length - keep);
+    return out;
+  };
+
   const closeTextBlock = function* () {
+    // Flush a held-back fragment that turned out not to be a tag.
+    if (_tagTail && !_inThink && textIndex !== null) {
+      yield _sse("content_block_delta", {
+        type: "content_block_delta",
+        index: textIndex,
+        delta: { type: "text_delta", text: _tagTail },
+      });
+      _tagTail = "";
+    }
     if (textIndex === null) return;
     yield _sse("content_block_stop", { type: "content_block_stop", index: textIndex });
     textIndex = null;
@@ -217,19 +272,22 @@ async function* _openaiToAnthropicEvents(upstream, opts = {}) {
       // Text deltas are straightforward: open a block on first text, then
       // emit a text_delta per chunk.
       if (typeof delta.content === "string" && delta.content.length > 0) {
-        if (textIndex === null) {
-          textIndex = nextIndex++;
-          yield _sse("content_block_start", {
-            type: "content_block_start",
+        const visible = filterThink(delta.content);
+        if (visible.length > 0) {
+          if (textIndex === null) {
+            textIndex = nextIndex++;
+            yield _sse("content_block_start", {
+              type: "content_block_start",
+              index: textIndex,
+              content_block: { type: "text", text: "" },
+            });
+          }
+          yield _sse("content_block_delta", {
+            type: "content_block_delta",
             index: textIndex,
-            content_block: { type: "text", text: "" },
+            delta: { type: "text_delta", text: visible },
           });
         }
-        yield _sse("content_block_delta", {
-          type: "content_block_delta",
-          index: textIndex,
-          delta: { type: "text_delta", text: delta.content },
-        });
       }
 
       // Tool-call fragments: accumulate per OpenAI tool index. Fragments of

package/src/policy/safe-commands.js

@@ -1,4 +1,3 @@
-const logger = require("../logger");
 const config = require("../config");
 
 /**

package/src/routing/calibration.js

@@ -19,6 +19,8 @@ const path = require('path');
 
 const DEFAULT_DAYS = 7;
 const MIN_SAMPLES = 100;
+/** Narrower than this and a calibrated band is treated as collapse, not signal. */
+const MIN_TIER_WIDTH = 10;
 
 /** Quality score below which a complexity bucket is "underperforming" for its tier. */
 const QUALITY_FLOOR = {
@@ -188,7 +190,24 @@ function runCalibration({ days = DEFAULT_DAYS, dryRun = false, dbPath, outputPat
     const prev = ranges[tierOrder[i - 1]];
     const cur = ranges[tierOrder[i]];
     if (cur[0] !== prev[1] + 1) cur[0] = prev[1] + 1;
-    if (cur[0] > cur[1]) cur[1] = cur[0]; // collapsed; tier disabled in practice
+    if (cur[0] > cur[1]) cur[1] = cur[0]; // collapsed; see guardrail below
+  }
+
+  // Guardrail: a tier squeezed under MIN_TIER_WIDTH means calibration had
+  // degenerate signal, not a real finding — e.g. 2026-07-26 (MEDIUM →
+  // [20,20]) and 2026-08-22 (COMPLEX → [51,54], which re-stitched
+  // REASONING's floor down to 55 and sent ~all agentic traffic to the most
+  // expensive tier; skewed telemetry then re-taught the same bands every
+  // 24h). Collapsed bands revert the whole set to DEFAULT_RANGES — bands
+  // are interdependent after stitching, so partial reverts would leave
+  // gaps.
+  const collapsed = tierOrder.filter(
+    (t) => ranges[t][1] - ranges[t][0] < MIN_TIER_WIDTH
+  );
+  let guardrail = null;
+  if (collapsed.length > 0) {
+    guardrail = { reverted: true, reason: 'band_collapse', collapsed };
+    for (const t of tierOrder) ranges[t] = [...DEFAULT_RANGES[t]];
   }
 
   const out = {
@@ -197,6 +216,7 @@ function runCalibration({ days = DEFAULT_DAYS, dryRun = false, dbPath, outputPat
     sampleCount: rows.length,
     ranges,
     stats,
+    ...(guardrail ? { guardrail } : {}),
   };
 
   if (dryRun) return { ...out, dryRun: true };

package/src/routing/client-profiles.js

@@ -114,6 +114,32 @@ const PROFILES = {
       minToolFingerprintMatch: 0.5,
     },
   },
+  'opencode': {
+    name: 'opencode',
+    baselineTools: new Set([
+      // OpenCode 1.18.x default loadout — captured live 2026-08-22 from
+      // Lynkr logs (user-agent `opencode/1.18.21 ai-sdk/provider-utils/…`).
+      // All of these attach to every request; counting them as intent
+      // scored every OpenCode turn ~80 → REASONING band → session pin
+      // locked the whole session there (2026-08-22: 1163/1203 REASONING
+      // routings were pin-inherited from a floored first turn).
+      'bash', 'edit', 'glob', 'grep', 'question', 'read', 'skill', 'task',
+      'todowrite', 'webfetch', 'write',
+      // Per opencode.ai/docs/tools — enabled-by-default or common-config
+      // names not seen in our capture; harmless if absent (subtraction
+      // only removes names actually present).
+      'list', 'todoread', 'websearch',
+    ]),
+    detect: {
+      headerPatterns: [/opencode/i],
+      // 0.5 (like goose): `question`/`skill`/`todo*` vary with user config,
+      // so a minimal loadout matches ~8 of 14 baseline names. The lowercase
+      // set is disjoint from claude-code's capitalized and cursor's
+      // snake_case names, and opencode always sends its user-agent, so the
+      // header pattern is the primary detector anyway.
+      minToolFingerprintMatch: 0.5,
+    },
+  },
   'openai-codex': {
     name: 'openai-codex',
     baselineTools: new Set([

package/src/routing/complexity-analyzer.js

@@ -44,7 +44,7 @@ function _effectiveTools(payload) {
 // Pre-compiled regex patterns for performance
 const PATTERNS = {
   // Greetings - always local
-  greeting: /^(hi|hello|hey|good\s*(morning|afternoon|evening)|howdy|greetings|sup|yo|thanks?|thank\s*you)[\s\.\!\?,]*$/i,
+  greeting: /^(hi|hello|hey|good\s*(morning|afternoon|evening)|howdy|greetings|sup|yo|thanks?|thank\s*you)[\s.!?,]*$/i,
 
   // Simple questions - likely local
   simpleQuestion: /^(what\s+is|what's|define|who\s+is|when\s+was|where\s+is)\s+\w/i,
@@ -56,7 +56,7 @@ const PATTERNS = {
   technical: /\b(code|function|class|method|variable|api|database|server|client|module|import|export|async|await|promise|component|interface|type|struct|enum)\b/i,
 
   // File/path references
-  fileReference: /\b(\w+\.(js|ts|py|rb|go|rs|java|cpp|c|h|jsx|tsx|vue|svelte|md|json|yaml|yml|toml|sql|sh|bash))\b|[\.\/]\w+\//i,
+  fileReference: /\b(\w+\.(js|ts|py|rb|go|rs|java|cpp|c|h|jsx|tsx|vue|svelte|md|json|yaml|yml|toml|sql|sh|bash))\b|[./]\w+\//i,
 };
 
 // ============================================================================
@@ -119,10 +119,10 @@ const FORCE_CLOUD_PATTERNS = [
 
 // Force local patterns - always route to local regardless of score
 const FORCE_LOCAL_PATTERNS = [
-  /^(hi|hello|hey|thanks?|thank\s*you|bye|goodbye)[\s\.\!\?]*$/i,
+  /^(hi|hello|hey|thanks?|thank\s*you|bye|goodbye)[\s.!?]*$/i,
   /^what\s+(time|day|date)\s+is\s+it/i,
-  /^(yes|no|ok|okay|sure|got\s+it|understood)[\s\.\!\?]*$/i,
-  /^(help|menu|commands?|options?)[\s\.\!\?]*$/i,
+  /^(yes|no|ok|okay|sure|got\s+it|understood)[\s.!?]*$/i,
+  /^(help|menu|commands?|options?)[\s.!?]*$/i,
 ];
 
 // Weighted Scoring (15 Dimensions)
@@ -478,8 +478,6 @@ function scoreTools(payload) {
  * Score based on task type (0-25 points)
  */
 function scoreTaskType(content) {
-  const contentLower = content.toLowerCase();
-
   // Check force patterns first (priority: REASONING > cloud > local)
   for (const pattern of FORCE_REASONING_PATTERNS) {
     if (pattern.test(content)) {
@@ -796,7 +794,6 @@ async function analyzeComplexity(payload, options = {}) {
   if (useWeighted) {
     const weighted = calculateWeightedScore(workingPayload, content);
     const threshold = getThreshold();
-    const mode = config.smartToolSelection?.mode ?? 'heuristic';
 
     // Check force patterns
     const taskTypeResult = scoreTaskType(content);

package/src/routing/confidence-scorer.js

@@ -82,8 +82,8 @@ function scoreCode(response) {
   const fenced = (text.match(/```[\s\S]*?```/g) || []).join('\n');
   if (!fenced) return 0.6; // Code-gen request without code is suspicious
   // Very basic balance check
-  const opens = (fenced.match(/[\{\[\(]/g) || []).length;
-  const closes = (fenced.match(/[\}\]\)]/g) || []).length;
+  const opens = (fenced.match(/[{[(]/g) || []).length;
+  const closes = (fenced.match(/[}\])]/g) || []).length;
   if (Math.abs(opens - closes) > 2) return 0.5;
   return 0.9;
 }

package/src/routing/cost-optimizer.js

@@ -5,9 +5,8 @@
  */
 
 const logger = require('../logger');
-const config = require('../config');
 const { getModelRegistry, getModelRegistrySync } = require('./model-registry');
-const { getModelTierSelector, TIER_DEFINITIONS } = require('./model-tiers');
+const { getModelTierSelector } = require('./model-tiers');
 const { ratioFor } = require('./output-ratios');
 
 // Session cost tracking (in-memory)

package/src/routing/deescalator.js

@@ -57,7 +57,7 @@ function _lowerTier(tier) {
  * @param {Function} [args.deps.now] - Override Date.now() for tests.
  * @returns {string|null} The lower tier, or null if demotion is not warranted.
  */
-function suggestDemotion({ tier, requestType, analysis, deps = {} } = {}) {
+function suggestDemotion({ tier, requestType, analysis: _analysis, deps = {} } = {}) {
   if (!tier || !requestType) return null;
   const lower = _lowerTier(tier);
   if (!lower) return null;

package/src/routing/embedding-cache.js

@@ -6,7 +6,6 @@
  */
 
 const crypto = require('crypto');
-const logger = require('../logger');
 
 const DEFAULT_MAX = 5000;
 

package/src/routing/intent-score.js

@@ -206,7 +206,6 @@ function classify(embedding, centroids) {
  * Lexical fallback path stays clamped ≤75 (see _lexicalCleanScore).
  */
 function blendScore(sims) {
-  const classes = Object.keys(CLASS_VALUES);
   // Frontier similarity floor: a weak topical match can't jump tiers.
   const frontierSim = sims.frontier ?? -1;
   const activeSims = { ...sims };

package/src/routing/knn-router.js

@@ -22,7 +22,11 @@ const logger = require('../logger');
 const { generateEmbedding } = require('../cache/embeddings');
 const { getEmbeddingCache } = require('./embedding-cache');
 
-const INDEX_DIR = path.join(__dirname, '../../data/knn');
+// LYNKR_KNN_DIR override exists so test runs point at a scratch dir instead
+// of the production index — parallel test processes saving to the real path
+// produced a torn read → corrupt link-list lengths → a 135GB zero-filled
+// index file (2026-08-21).
+const INDEX_DIR = process.env.LYNKR_KNN_DIR || path.join(__dirname, '../../data/knn');
 const INDEX_FILE = path.join(INDEX_DIR, 'index.hnsw');
 const META_FILE = path.join(INDEX_DIR, 'meta.json');
 
@@ -85,7 +89,7 @@ class KnnRouter {
       // (Earlier Lynkr code passed MAX_ELEMENTS here — wrong type, threw on load.)
       this.index.readIndexSync(INDEX_FILE, false);
       // resize if needed so we can keep adding up to MAX_ELEMENTS
-      try { this.index.resizeIndex(MAX_ELEMENTS); } catch (_) {}
+      try { this.index.resizeIndex(MAX_ELEMENTS); } catch (err) { logger.debug({ err: err.message }, '[KnnRouter] resizeIndex failed — index may not grow past loaded size'); }
       this.ready = true;
       logger.info({ size: this.size, dim: this.dim }, '[KnnRouter] Index loaded');
       return true;
@@ -99,8 +103,26 @@ class KnnRouter {
     if (!this.ready || !this.index) return;
     try {
       fs.mkdirSync(INDEX_DIR, { recursive: true });
-      this.index.writeIndexSync(INDEX_FILE);
-      fs.writeFileSync(META_FILE, JSON.stringify({ dim: this.dim, entries: this.meta }, null, 0));
+      // Atomic save: hnswlib's writeIndexSync is truncate-then-write, so a
+      // concurrent reader can observe a torn image and later persist a
+      // corrupt index. Write to a per-pid temp file and rename into place —
+      // readers then always see a complete image.
+      const tmpIndex = `${INDEX_FILE}.tmp-${process.pid}`;
+      const tmpMeta = `${META_FILE}.tmp-${process.pid}`;
+      this.index.writeIndexSync(tmpIndex);
+      // Sanity bound: a healthy index is ~(elements × ~3.3KB) + slack. A
+      // corrupted link-list length manifests as a wildly oversized file —
+      // refuse to install it over the good one.
+      const expectedMax = (this.size + 1000) * 8192 + 1_000_000;
+      const written = fs.statSync(tmpIndex).size;
+      if (written > expectedMax) {
+        fs.rmSync(tmpIndex, { force: true });
+        logger.error({ written, expectedMax, size: this.size }, '[KnnRouter] Refusing to save implausibly large index — in-memory index likely corrupt');
+        return;
+      }
+      fs.writeFileSync(tmpMeta, JSON.stringify({ dim: this.dim, entries: this.meta }, null, 0));
+      fs.renameSync(tmpIndex, INDEX_FILE);
+      fs.renameSync(tmpMeta, META_FILE);
     } catch (err) {
       logger.warn({ err: err.message }, '[KnnRouter] Index save failed');
     }
@@ -197,7 +219,7 @@ class KnnRouter {
 
     let best = null;
     let bestScore = -Infinity;
-    for (const [model, agg] of byModel) {
+    for (const [, agg] of byModel) {
       const avgQ = agg.quality / agg.weight;
       const avgC = agg.cost / agg.weight;
       // Score = quality / log(cost+1) — reward quality, penalise cost gently

package/src/routing/latency-tracker.js

@@ -95,7 +95,7 @@ class LatencyTracker {
     }
     // Aggregate across all models for this provider
     const provEntries = [];
-    for (const [k, entry] of this._entries) {
+    for (const [_k, entry] of this._entries) {
       if (entry.provider === provider) provEntries.push(entry);
     }
     if (provEntries.length === 0) return null;

package/src/routing/regret-estimator.js

@@ -68,7 +68,7 @@ async function estimate(args) {
       fs.mkdirSync(path.dirname(ALERTS_PATH), { recursive: true });
       let existing = [];
       if (fs.existsSync(ALERTS_PATH)) {
-        try { existing = JSON.parse(fs.readFileSync(ALERTS_PATH, 'utf8')); } catch {}
+        try { existing = JSON.parse(fs.readFileSync(ALERTS_PATH, 'utf8')); } catch (err) { logger.debug({ err: err.message }, '[RegretEstimator] Existing alerts file unreadable — starting fresh'); }
       }
       const out = Array.isArray(existing) ? existing : [];
       out.push(...alerts);

package/src/stores/file-store.js

@@ -89,7 +89,11 @@ async function getFileContent(id) {
 async function deleteFile(id) {
   const entry = metadata.get(id);
   if (!entry) return false;
-  try { await fsp.unlink(entry.storage_path); } catch {}
+  try {
+    await fsp.unlink(entry.storage_path);
+  } catch (err) {
+    logger.debug({ err: err.message, fileId: id }, "Best-effort unlink failed during file delete");
+  }
   metadata.delete(id);
   persistMetadata();
   return true;

package/src/training/trajectory-compressor.js

@@ -38,7 +38,7 @@ const telemetry = require("../routing/telemetry");
 const ANONYMIZE_PATTERNS = [
   // API keys and bearer tokens
   [/sk-[A-Za-z0-9_-]{20,}/g, "<API_KEY>"],
-  [/Bearer\s+[A-Za-z0-9._\-]+/gi, "Bearer <REDACTED>"],
+  [/Bearer\s+[A-Za-z0-9._-]+/gi, "Bearer <REDACTED>"],
   [/dapi_[A-Za-z0-9_-]+/g, "<DATABRICKS_KEY>"],
   [/eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g, "<JWT>"],
   // AWS keys

package/src/workers/pool.js

@@ -310,7 +310,7 @@ class WorkerPool {
     logger.info('[WorkerPool] Shutting down...');
 
     // Reject all pending tasks
-    for (const [taskId, pending] of this.pendingTasks) {
+    for (const [_taskId, pending] of this.pendingTasks) {
       clearTimeout(pending.timeout);
       pending.reject(new Error('Worker pool shutting down'));
     }

package/src/workers/worker.js

@@ -65,7 +65,7 @@ const handlers = {
     let tokensReduced = 0;
     const seenToolResults = new Map(); // For deduplication
 
-    const transformed = messages.map((msg, idx) => {
+    const transformed = messages.map((msg) => {
       if (!msg) return msg;
 
       // Clone to avoid mutating original

package/scripts/convert-routellm.py

@@ -1,105 +0,0 @@
-#!/usr/bin/env python3
-"""
-Convert routellm/gpt4_dataset (train.jsonl) → Lynkr kNN bootstrap JSONL.
-
-Stream-downloads from HuggingFace and maps mixtral_score (1-5) to your
-TIER_* model config so the kNN index learns to recommend YOUR real models,
-not RouteLLM's pool (mixtral / gpt-4).
-
-Output format matches scripts/build-knn-index.js bootstrap input:
-    {"query": "...", "provider": "ollama", "model": "minimax-m2.5:cloud",
-     "quality": 95, "cost": 0.001, "latency": 200, "tier": "SIMPLE"}
-
-Usage:
-    .venv/bin/python scripts/convert-routellm.py [--limit 30000] -o routellm.jsonl
-"""
-import argparse
-import json
-import sys
-import urllib.request
-import ssl
-
-# Map mixtral_score → user's tier config.
-# Spread is intentionally aggressive: only score=5 (Mixtral truly nailed it)
-# stays SIMPLE; score=4 escalates to MEDIUM so the kNN index has enough MEDIUM
-# examples to actually recommend non-SIMPLE tiers (vs the previous mapping
-# where 86% of records were SIMPLE and kNN never disagreed with the heuristic).
-SCORE_TO_ROUTE = {
-    5: {"tier": "SIMPLE",    "provider": "ollama",          "model": "minimax-m2.5:cloud", "quality": 95, "cost": 0.001, "latency": 200},
-    4: {"tier": "MEDIUM",    "provider": "azure-anthropic", "model": "claude-sonnet-4-6",  "quality": 80, "cost": 0.003, "latency": 1500},
-    3: {"tier": "MEDIUM",    "provider": "azure-anthropic", "model": "claude-sonnet-4-6",  "quality": 70, "cost": 0.003, "latency": 1500},
-    2: {"tier": "COMPLEX",   "provider": "azure-anthropic", "model": "claude-sonnet-4-6",  "quality": 55, "cost": 0.003, "latency": 1500},
-    1: {"tier": "REASONING", "provider": "azure-anthropic", "model": "claude-opus-4-8",    "quality": 40, "cost": 0.015, "latency": 3500},
-}
-
-URL = "https://huggingface.co/datasets/routellm/gpt4_dataset/resolve/main/train.jsonl"
-
-
-def main():
-    p = argparse.ArgumentParser()
-    p.add_argument("--output", "-o", default="data/routellm-bootstrap.jsonl")
-    p.add_argument("--limit", type=int, default=None,
-                   help="Only convert first N rows")
-    args = p.parse_args()
-
-    print(f"Streaming {URL} …", file=sys.stderr)
-    # Some macOS Python builds have SSL issues with huggingface.co — fall back
-    # to unverified context if needed. The data is public, no auth.
-    ctx = ssl.create_default_context()
-    try:
-        with urllib.request.urlopen(URL, context=ctx, timeout=60) as resp:
-            _stream(resp, args.output, args.limit)
-    except (ssl.SSLError, OSError) as e:
-        print(f"SSL strict failed ({e}); retrying with unverified context", file=sys.stderr)
-        ctx = ssl._create_unverified_context()
-        with urllib.request.urlopen(URL, context=ctx, timeout=60) as resp:
-            _stream(resp, args.output, args.limit)
-
-
-def _stream(resp, out_path, limit):
-    written = 0
-    by_score = {s: 0 for s in SCORE_TO_ROUTE}
-    skipped = 0
-    with open(out_path, "w") as out:
-        for line in resp:
-            if limit and written >= limit:
-                break
-            try:
-                row = json.loads(line)
-            except Exception:
-                skipped += 1
-                continue
-            score = row.get("mixtral_score")
-            if score not in SCORE_TO_ROUTE:
-                skipped += 1
-                continue
-            route = SCORE_TO_ROUTE[score]
-            rec = {
-                "query": row.get("prompt", ""),
-                "provider": route["provider"],
-                "model": route["model"],
-                "quality": route["quality"],
-                "cost": route["cost"],
-                "latency": route["latency"],
-                "tier": route["tier"],
-            }
-            if not rec["query"]:
-                skipped += 1
-                continue
-            out.write(json.dumps(rec) + "\n")
-            written += 1
-            by_score[score] += 1
-            if written % 5000 == 0:
-                print(f"  {written} written…", file=sys.stderr)
-
-    print(f"\nWrote {written} records to {out_path} ({skipped} skipped)", file=sys.stderr)
-    print(f"By mixtral_score: {by_score}", file=sys.stderr)
-    print(f"\nTier distribution:", file=sys.stderr)
-    for score, route in SCORE_TO_ROUTE.items():
-        n = by_score[score]
-        if n:
-            print(f"  {route['tier']:>10}  {route['provider']}:{route['model']:30s}  n={n}", file=sys.stderr)
-
-
-if __name__ == "__main__":
-    main()

package/src/diff/comments.js

@@ -1,153 +0,0 @@
-const crypto = require("crypto");
-const db = require("../db");
-const logger = require("../logger");
-
-const insertCommentStmt = db.prepare(
-  `INSERT INTO diff_comments (
-     thread_id,
-     session_id,
-     file_path,
-     hunk,
-     line,
-     comment,
-     author,
-     created_at,
-     metadata
-   ) VALUES (
-     @thread_id,
-     @session_id,
-     @file_path,
-     @hunk,
-     @line,
-     @comment,
-     @author,
-     @created_at,
-     @metadata
-   )`,
-);
-
-const deleteCommentStmt = db.prepare("DELETE FROM diff_comments WHERE id = ?");
-
-function buildSelectCommentsQuery({ filePath, threadId }) {
-  let sql = `SELECT id,
-                    thread_id,
-                    session_id,
-                    file_path,
-                    hunk,
-                    line,
-                    comment,
-                    author,
-                    created_at,
-                    metadata
-             FROM diff_comments`;
-  const conditions = [];
-  const params = [];
-  if (filePath) {
-    conditions.push("file_path = ?");
-    params.push(filePath);
-  }
-  if (threadId) {
-    conditions.push("thread_id = ?");
-    params.push(threadId);
-  }
-  if (conditions.length) {
-    sql += ` WHERE ${conditions.join(" AND ")}`;
-  }
-  sql += " ORDER BY created_at ASC, id ASC";
-  return { sql, params };
-}
-
-function normaliseCommentRow(row) {
-  return {
-    id: row.id,
-    threadId: row.thread_id ?? null,
-    sessionId: row.session_id ?? null,
-    filePath: row.file_path,
-    hunk: row.hunk ?? null,
-    line: typeof row.line === "number" ? row.line : null,
-    comment: row.comment,
-    author: row.author ?? null,
-    createdAt: row.created_at,
-    metadata: row.metadata ? JSON.parse(row.metadata) : null,
-  };
-}
-
-function addDiffComment({
-  threadId,
-  sessionId,
-  filePath,
-  line,
-  hunk,
-  comment,
-  author,
-  metadata,
-}) {
-  if (typeof filePath !== "string" || filePath.trim().length === 0) {
-    throw new Error("Diff comment requires a file path.");
-  }
-  if (typeof comment !== "string" || comment.trim().length === 0) {
-    throw new Error("Diff comment requires non-empty comment text.");
-  }
-
-  const createdAt = Date.now();
-  const thread = threadId ?? crypto.randomUUID();
-
-  const params = {
-    thread_id: thread,
-    session_id: sessionId ?? null,
-    file_path: filePath,
-    hunk: hunk ?? null,
-    line: typeof line === "number" ? line : null,
-    comment,
-    author: author ?? null,
-    created_at: createdAt,
-    metadata: metadata ? JSON.stringify(metadata) : null,
-  };
-
-  const result = insertCommentStmt.run(params);
-
-  logger.debug(
-    {
-      id: result.lastInsertRowid,
-      thread,
-      filePath,
-      line,
-    },
-    "Recorded diff comment",
-  );
-
-  return normaliseCommentRow({
-    id: result.lastInsertRowid,
-    thread_id: thread,
-    session_id: sessionId ?? null,
-    file_path: filePath,
-    hunk: hunk ?? null,
-    line: typeof line === "number" ? line : null,
-    comment,
-    author: author ?? null,
-    created_at: createdAt,
-    metadata: metadata ? JSON.stringify(metadata) : null,
-  });
-}
-
-function listDiffComments({ filePath, threadId } = {}) {
-  const { sql, params } = buildSelectCommentsQuery({ filePath, threadId });
-  return db
-    .prepare(sql)
-    .all(...params)
-    .map(normaliseCommentRow);
-}
-
-function deleteDiffComment({ id }) {
-  if (!id) {
-    throw new Error("diff_comment_delete requires an id.");
-  }
-  const result = deleteCommentStmt.run(id);
-  return result.changes > 0;
-}
-
-module.exports = {
-  addDiffComment,
-  listDiffComments,
-  deleteDiffComment,
-};