@ijfw/memory-server 1.4.3 → 1.5.0

package/src/cost/pricing.js

@@ -116,6 +116,63 @@ export function computeCost(modelId, usage) {
   );
 }
 
+/**
+ * Per-tier dashboard view ($/M tokens).
+ * Single source of truth for any UI that wants to show Anthropic family
+ * rates without hardcoding numbers. Derived from the canonical model_prices
+ * table via the same getPricing() resolver everything else uses, so it
+ * cannot drift from receipt cost computation.
+ *
+ * Tiers are keyed by lowercase family name -- callers tier-match on
+ * model id substring (opus | sonnet | haiku). Values are USD per million
+ * tokens for input/output/cache_read/cache_creation.
+ */
+export function getTierRatesPerMillion() {
+  const M = 1_000_000;
+  const tiers = {
+    opus:   'claude-opus-4-1',
+    sonnet: 'claude-sonnet-4-5',
+    haiku:  'claude-haiku-4-5',
+  };
+  const out = {};
+  for (const [tier, modelId] of Object.entries(tiers)) {
+    const p = getPricing(modelId);
+    out[tier] = {
+      in:             p.in * M,
+      out:            p.out * M,
+      cache_read:     p.cache_read * M,
+      cache_creation: p.cache_create_5m * M,
+    };
+  }
+  return out;
+}
+
+/**
+ * Per-provider USD/token estimate for budget pre-flight (cross-dispatcher).
+ * One representative model per provider, resolved through the canonical
+ * pricing table so this cannot drift from receipt billing.
+ *
+ * Returns USD per *input* token (output is typically priced separately;
+ * pre-flight uses the conservative input-only estimate).
+ */
+const PROVIDER_DEFAULT_MODEL = {
+  claude:    'claude-sonnet-4-5',
+  anthropic: 'claude-sonnet-4-5',
+  codex:     'gpt-5',
+  opencode:  'gpt-5',
+  aider:     'gpt-5',
+  copilot:   'gpt-4o',
+  gemini:    'gemini/gemini-1.5-flash',
+};
+
+export function getProviderInputRate(providerId) {
+  const id = (providerId || '').toLowerCase().trim();
+  const modelId = PROVIDER_DEFAULT_MODEL[id];
+  if (!modelId) return null;
+  const p = getPricing(modelId);
+  return p.in;
+}
+
 /** Return the raw prices table for /api/prices transparency endpoint. */
 export function getPricesTable() {
   const prices = loadPrices();

package/src/cost/readers/gemini.js

@@ -90,7 +90,7 @@ function processGeminiChat(chat, projectHash) {
     session_id: sessionId,
     project: projectHash,
     timestamp: lastTimestamp,
-    model: 'gemini-2.0-flash', // Gemini CLI default; no model id in chat file
+    model: 'gemini-3.1-pro', // Gemini CLI default; no model id in chat file
     input_tokens: inputTokens,
     output_tokens: outputTokens,
     cache_create_tokens_5m: 0,

package/src/cross-audit-chunker.js

@@ -0,0 +1,189 @@
+// r17.1 (item 5) — Chunking strategy for cross-audit on large targets.
+//
+// Cross-audit's auditors (codex / gemini / claude / etc) all have practical
+// input limits well below the 64 KB target cap — and even at the cap, audit
+// quality degrades because the model is asked to grade ~20K tokens at once.
+// This module splits a large target into overlapping chunks, lets the caller
+// audit each chunk independently, then merges + dedupes the findings.
+//
+// Design choices:
+//   - Boundary-aware split: prefers blank-line, then sentence, then word, then
+//     character. Audit quality drops sharply when a chunk ends mid-thought.
+//   - Overlapping chunks: ~10% overlap so findings near a boundary appear in
+//     both neighbors and dedup catches them as a single finding.
+//   - Finding shape match: hybrid with the existing finding structure from
+//     `printFindings`: { severity, target, finding, action } (severity is
+//     'high' | 'medium' | 'low'). Unknown keys preserved.
+//   - Dedupe: case-insensitive jaccard over the (target + finding) text. A
+//     duplicate threshold of 0.85 is the default; configurable via opts.
+
+const DEFAULT_CHUNK_SIZE = Math.floor(64 * 1024 * 0.9);   // 90% of TARGET_FILE_SIZE_CAP
+const DEFAULT_OVERLAP    = Math.floor(64 * 1024 * 0.10);  // 10%
+const SEVERITY_RANK      = { high: 3, medium: 2, low: 1 };
+
+/**
+ * Split text into overlapping chunks at the best boundary available.
+ *
+ * @param {string} text                - the text to chunk
+ * @param {object} [opts]
+ * @param {number} [opts.chunkSize]    - max chars per chunk (default 90% of cap)
+ * @param {number} [opts.overlap]      - chars of overlap (default 10% of cap)
+ * @returns {Array<{ index: number, start: number, end: number, text: string }>}
+ */
+export function chunkText(text, opts = {}) {
+  if (typeof text !== 'string' || text.length === 0) return [];
+
+  const chunkSize = Math.max(1024, opts.chunkSize ?? DEFAULT_CHUNK_SIZE);
+  // r17-M1: clamp overlap to <= chunkSize/2 so the advance step is always
+  // strictly forward. Without this, opts.chunkSize=500 + default overlap
+  // (~6553) would set start to max(start+1, cutEnd - 6553) and the loop
+  // would advance one char per iteration on small chunks.
+  const overlap   = Math.min(Math.floor(chunkSize / 2), Math.max(0, opts.overlap ?? DEFAULT_OVERLAP));
+
+  // Tiny text: one chunk.
+  if (text.length <= chunkSize) {
+    return [{ index: 0, start: 0, end: text.length, text }];
+  }
+
+  const chunks = [];
+  let start = 0;
+  let index = 0;
+  while (start < text.length) {
+    const remaining = text.length - start;
+    if (remaining <= chunkSize) {
+      chunks.push({ index, start, end: text.length, text: text.slice(start) });
+      break;
+    }
+
+    // Find the best boundary within [start + chunkSize - 1024, start + chunkSize].
+    // We slide LEFT from the nominal end looking for a clean break point.
+    const nominalEnd = start + chunkSize;
+    const searchFloor = Math.max(start + 1, nominalEnd - 1024);
+    let cutEnd = nominalEnd;
+
+    // Prefer blank-line boundary.
+    let p = text.lastIndexOf('\n\n', nominalEnd);
+    if (p >= searchFloor) {
+      cutEnd = p + 2;
+    } else {
+      // Try sentence-ending punctuation.
+      p = Math.max(
+        text.lastIndexOf('. ', nominalEnd),
+        text.lastIndexOf('! ', nominalEnd),
+        text.lastIndexOf('? ', nominalEnd),
+        text.lastIndexOf('.\n', nominalEnd),
+      );
+      if (p >= searchFloor) {
+        cutEnd = p + 2;
+      } else {
+        // Try a single newline.
+        p = text.lastIndexOf('\n', nominalEnd);
+        if (p >= searchFloor) cutEnd = p + 1;
+        // Else fall through to nominal char boundary.
+      }
+    }
+
+    chunks.push({ index, start, end: cutEnd, text: text.slice(start, cutEnd) });
+    index++;
+    // Advance with overlap.
+    start = Math.max(start + 1, cutEnd - overlap);
+  }
+  return chunks;
+}
+
+// Normalize finding shape — accept {severity, finding, target, action} OR
+// {severity, message} OR raw strings; coerce to a common shape.
+// v1.5.0 wire-W4: widened the field-name fallback chain to cover the field
+// names auditors actually emit. Trident r19 dropped 100% of finding text to
+// "(no detail)" because the lens responses used `description`/`issue`/`detail`
+// rather than `finding`/`message`/`text`. r20 captures them properly.
+function normaliseFinding(raw) {
+  if (typeof raw === 'string') {
+    return { severity: 'medium', finding: raw, target: '', action: '' };
+  }
+  if (!raw || typeof raw !== 'object') return null;
+  return {
+    severity: String(raw.severity || 'medium').toLowerCase(),
+    finding:  String(
+      raw.finding || raw.message || raw.text || raw.description ||
+      raw.issue || raw.detail || raw.details || raw.note || raw.summary || ''
+    ),
+    target:   String(
+      raw.target || raw.location || raw.path || raw.file ||
+      raw.where || raw.line || ''
+    ),
+    action:   String(
+      raw.action || raw.fix || raw.recommendation ||
+      raw.suggestion || raw.remediation || ''
+    ),
+    // preserve unknown keys for printers that want them
+    _extra: raw,
+  };
+}
+
+// Jaccard similarity on lowercased word sets. Cheap, deterministic, gives
+// "are these two findings essentially the same?" for free.
+function jaccard(a, b) {
+  const tokA = new Set(String(a).toLowerCase().split(/\W+/).filter(t => t.length > 2));
+  const tokB = new Set(String(b).toLowerCase().split(/\W+/).filter(t => t.length > 2));
+  if (tokA.size === 0 && tokB.size === 0) return 1;
+  let inter = 0;
+  for (const t of tokA) if (tokB.has(t)) inter++;
+  const uni = tokA.size + tokB.size - inter;
+  return uni === 0 ? 0 : inter / uni;
+}
+
+/**
+ * Merge findings from per-chunk audits. Dedupes near-duplicates (Jaccard ≥
+ * threshold) and keeps the max severity from each cluster.
+ *
+ * @param {Array<{ chunkIndex: number, findings: Array }>} perChunkResults
+ * @param {object} [opts]
+ * @param {number} [opts.dedupeThreshold]  - Jaccard threshold (default 0.85)
+ * @returns {Array}  - merged + deduped findings, sorted high→low severity
+ */
+export function mergeFindings(perChunkResults, opts = {}) {
+  const threshold = opts.dedupeThreshold ?? 0.85;
+  const flat = [];
+  for (const r of perChunkResults || []) {
+    const chunkIndex = typeof r.chunkIndex === 'number' ? r.chunkIndex : null;
+    const findings = Array.isArray(r.findings) ? r.findings : [];
+    for (const raw of findings) {
+      const n = normaliseFinding(raw);
+      if (n) flat.push({ ...n, chunkIndex });
+    }
+  }
+  if (flat.length === 0) return [];
+
+  // Cluster by jaccard. Each cluster's representative is the first member;
+  // we keep the MAX severity across the cluster and record `clusterSize`.
+  const clusters = [];
+  for (const f of flat) {
+    const key = `${f.target} ${f.finding}`;
+    let placed = false;
+    for (const c of clusters) {
+      const repKey = `${c.target} ${c.finding}`;
+      if (jaccard(key, repKey) >= threshold) {
+        c._members.push(f);
+        if ((SEVERITY_RANK[f.severity] || 0) > (SEVERITY_RANK[c.severity] || 0)) {
+          c.severity = f.severity;
+        }
+        placed = true;
+        break;
+      }
+    }
+    if (!placed) clusters.push({ ...f, _members: [f] });
+  }
+
+  // Stamp clusterSize + clusterChunks for printers + sort by severity desc.
+  for (const c of clusters) {
+    c.clusterSize = c._members.length;
+    c.clusterChunks = [...new Set(c._members.map(m => m.chunkIndex).filter(i => i !== null))];
+    delete c._members;
+  }
+  clusters.sort((a, b) => (SEVERITY_RANK[b.severity] || 0) - (SEVERITY_RANK[a.severity] || 0));
+  return clusters;
+}
+
+// Constants exported so consumers + tests can reference the same defaults.
+export const CHUNKER_DEFAULTS = { chunkSize: DEFAULT_CHUNK_SIZE, overlap: DEFAULT_OVERLAP, dedupeThreshold: 0.85 };

package/src/cross-dispatcher.js

@@ -10,8 +10,45 @@
 // Internal templates
 // ---------------------------------------------------------------------------
 
+// v1.5.0 audit-MED-trident-M8 — single canonical severity taxonomy.
+// Findings use CRITICAL/HIGH/MEDIUM/LOW (security-style). Audit DISPOSITIONS
+// (PASS/CONDITIONAL/WARN/FLAG/FAIL) are a separate axis — they describe the
+// audit's *status*, not a finding's *severity*. mergeAudit normalizes any
+// disposition values that slip in as `severity` so they no longer sink to
+// the "unrecognized" bottom of the list.
 const SEVERITY_ORDER = { critical: 0, high: 1, medium: 2, low: 3 };
 
+// M8: map trident dispatch dispositions → finding severities. Used by
+// mergeAudit to coerce stray disposition-valued severities into the canonical
+// taxonomy before sorting. A finding tagged `severity:'warn'` is treated as
+// medium; `flag` as high; `fail` as critical; `pass` as low; `conditional`
+// as medium. Callers that legitimately want disposition values should put
+// them on a separate `disposition` field.
+const DISPOSITION_TO_SEVERITY = {
+  pass:        'low',
+  conditional: 'medium',
+  warn:        'medium',
+  flag:        'high',
+  fail:        'critical',
+};
+
+// Public exports so downstream callers (status renderers, dashboard) share
+// the same vocabulary. M8 closure.
+export const FINDING_SEVERITIES = Object.freeze(['critical', 'high', 'medium', 'low']);
+export const AUDIT_DISPOSITIONS = Object.freeze(['pass', 'conditional', 'warn', 'flag', 'fail']);
+
+// normaliseSeverity -- coerce any stray value (disposition or unknown) into
+// a canonical finding severity. Returns the original lower-cased string when
+// already canonical; maps dispositions per DISPOSITION_TO_SEVERITY; returns
+// null on unknown input.
+export function normaliseSeverity(raw) {
+  if (raw == null) return null;
+  const v = String(raw).toLowerCase().trim();
+  if (SEVERITY_ORDER[v] !== undefined) return v;
+  if (DISPOSITION_TO_SEVERITY[v]) return DISPOSITION_TO_SEVERITY[v];
+  return null;
+}
+
 // Format-contract footer shared by all templates -- tells auditors the exact
 // fenced block schema to use so parseResponse can extract it reliably.
 function formatContract(schema) {
@@ -306,12 +343,83 @@ export function mergeResponses(mode, responses) {
   throw new Error(`Unknown mode: ${mode}`);
 }
 
+// v1.5.0 audit-MED-trident-M3 — consensus / contested clustering.
+// Before: findings from N lenses appeared N times in the user-visible list
+// because mergeAudit just flattened + sorted. With Trident running 3 lenses
+// on the same target, a real bug got reported 3 times and looked like 3 bugs.
+//
+// After: lexical-bucket-cluster on a normalized signature (issue + location
+// when available; falls back to text/description). A cluster touched by ≥2
+// lenses is tagged `consensus: true`, `consensusCount: N`, and `consensusLenses`
+// (array of lens ids when discoverable). Single-lens findings carry
+// `consensus: false`. Order: CONSENSUS group first (by severity), single-lens
+// group second (by severity). Within each group, sort by canonical severity
+// (M8 — disposition values are coerced before sort).
+//
+// The clustering is intentionally LEXICAL only — same heuristic as
+// mergeResearch's normaliseClaim. Semantic clustering (paraphrases that mean
+// the same thing) is delegated to the optional synthesis pass.
+function _findingSignature(item) {
+  // Prefer (issue + location) when present. Fallback chain: counterArg, text,
+  // description, then a stringified blob so two identical objects still match.
+  const loc   = String(item.location || item.file || '').toLowerCase().trim();
+  const issue = String(item.issue || item.counterArg || item.text || item.description || '').toLowerCase().trim();
+  if (issue) return `${issue}::${loc}`.replace(/\s+/g, ' ');
+  // Last-resort signature: JSON of the item, sorted-keys.
+  try {
+    return JSON.stringify(item, Object.keys(item || {}).sort()).toLowerCase();
+  } catch {
+    return String(item).toLowerCase();
+  }
+}
+
+function _coercedSeverityRank(item) {
+  // M8: try canonical severity first, then disposition mapping, then 99.
+  const canon = normaliseSeverity(item.severity ?? item.level);
+  if (canon == null) return 99;
+  return SEVERITY_ORDER[canon] ?? 99;
+}
+
 function mergeAudit(responses) {
-  const all = responses.flatMap(r => (r && Array.isArray(r.items) ? r.items : []));
-  return all.slice().sort((a, b) => {
-    const sa = SEVERITY_ORDER[String(a.severity).toLowerCase()] ?? 99;
-    const sb = SEVERITY_ORDER[String(b.severity).toLowerCase()] ?? 99;
-    return sa - sb;
+  // Flatten with an auditor index so we can attribute consensus to lenses.
+  // responses may include an optional `_lens` / `auditorId` marker on each
+  // item (the orchestrator already stamps `_lens` in defaultConvergeDispatch
+  // merges). We honor it when present.
+  const buckets = new Map();
+  responses.forEach((r, auditorIdx) => {
+    const items = r && Array.isArray(r.items) ? r.items : [];
+    for (const item of items) {
+      const sig = _findingSignature(item);
+      if (!sig) continue;
+      if (!buckets.has(sig)) buckets.set(sig, []);
+      const lensId = item._lens || item.auditorId || String(auditorIdx);
+      buckets.get(sig).push({ item, lensId, auditorIdx });
+    }
+  });
+
+  const out = [];
+  for (const [, entries] of buckets) {
+    // Distinct lens count: a single lens can only contribute one vote to
+    // consensus (it may emit the same finding twice in its own list).
+    const distinctLenses = [...new Set(entries.map(e => e.lensId))];
+    const consensus = distinctLenses.length >= 2;
+    // Use the first entry as the representative finding (oldest wins);
+    // attach consensus metadata so consumers can group / highlight.
+    const rep = { ...entries[0].item };
+    if (consensus) {
+      rep.consensus = true;
+      rep.consensusCount = distinctLenses.length;
+      rep.consensusLenses = distinctLenses;
+    } else {
+      rep.consensus = false;
+    }
+    out.push(rep);
+  }
+
+  // Sort: consensus first, then by canonical severity (M8 disposition-coerce).
+  return out.sort((a, b) => {
+    if (a.consensus !== b.consensus) return a.consensus ? -1 : 1;
+    return _coercedSeverityRank(a) - _coercedSeverityRank(b);
   });
 }
 
@@ -371,9 +479,11 @@ function mergeCritique(responses) {
     const sa = scoreRebuttalSurvival(a);
     const sb = scoreRebuttalSurvival(b);
     if (sb !== sa) return sb - sa; // DESC survival
-    const ra = SEVERITY_ORDER[String(a.severity).toLowerCase()] ?? 99;
-    const rb = SEVERITY_ORDER[String(b.severity).toLowerCase()] ?? 99;
-    return ra - rb; // DESC severity (lower index = higher sev)
+    // M8: coerce dispositions (warn/flag/fail) to canonical severities so a
+    // counter-arg tagged `severity:'warn'` doesn't sink to bottom unranked.
+    const ra = _coercedSeverityRank(a);
+    const rb = _coercedSeverityRank(b);
+    return ra - rb; // ASC by canonical rank = DESC severity
   });
 }
 
@@ -381,18 +491,11 @@ function mergeCritique(responses) {
 // Budget guard (Step 10B.6)
 // ---------------------------------------------------------------------------
 
-// Rough per-token list prices (USD) for each provider family.
-// Used only for pre-flight estimation -- not for billing.
-// Prices are input-side costs at standard rates as of 2026.
-const PROVIDER_PRICE_PER_TOKEN = {
-  codex:     0.000_015,  // OpenAI o4-mini input ~$15/M
-  opencode:  0.000_015,
-  aider:     0.000_015,
-  gemini:    0.000_000_5, // Gemini 1.5 Flash input ~$0.50/M
-  copilot:   0.000_010,  // GPT-4o input ~$10/M (conservative)
-  claude:    0.000_003,  // Sonnet input ~$3/M
-  anthropic: 0.000_003,
-};
+// Per-provider input-token price (USD/token), sourced from the canonical
+// pricing module. Used only for pre-flight estimation -- not for billing.
+// Single source of truth = mcp-server/src/cost/pricing.js. H4.8 audit fix.
+import { getProviderInputRate } from './cost/pricing.js';
+
 const DEFAULT_PRICE_PER_TOKEN = 0.000_010; // fallback for unknown providers
 
 // estimateCost(target, picks) -- rough cost in USD for one runCrossOp call.
@@ -402,7 +505,7 @@ export function estimateCost(target, picks) {
   const tokens = charCount / 4;
   let total = 0;
   for (const pick of picks) {
-    const price = PROVIDER_PRICE_PER_TOKEN[pick.id] ?? DEFAULT_PRICE_PER_TOKEN;
+    const price = getProviderInputRate(pick.id) ?? DEFAULT_PRICE_PER_TOKEN;
     total += tokens * price;
   }
   return total;