analyzthis_design 2.5.1 → 2.5.2

package/dist/lib/evolution-metrics.js

@@ -109,6 +109,15 @@ function patchIsApplied(patch) {
 function collectSignals(projectIds, persona) {
   var outcomes = [];   // { value, source }
   var ratings = [];    // numbers
+  var byModel = {};
+
+  function modelBucket(attribution) {
+    var id = attribution && (attribution.model_id ||
+      (attribution.provider && attribution.model && attribution.provider + '/' + attribution.model));
+    id = id || 'unknown/unknown';
+    if (!byModel[id]) byModel[id] = { outcomes: 0, ratings: 0, rating_total: 0 };
+    return byModel[id];
+  }
 
   for (var i = 0; i < projectIds.length; i++) {
     var state = session.show({ project: projectIds[i] });
@@ -120,8 +129,10 @@ function collectSignals(projectIds, persona) {
     // A confirmed outcome supersedes an inferred one for the same persona.
     if (confirmed[persona] && confirmed[persona].value) {
       outcomes.push({ value: confirmed[persona].value, source: 'confirmed' });
+      modelBucket(confirmed[persona].attribution).outcomes++;
     } else if (inferred[persona] && inferred[persona].value) {
       outcomes.push({ value: inferred[persona].value, source: 'inferred' });
+      modelBucket(inferred[persona].attribution).outcomes++;
     }
 
     var log = state.feedback_log || [];
@@ -129,10 +140,20 @@ function collectSignals(projectIds, persona) {
       if (log[j].persona !== persona) continue;
       if (log[j].rating == null) continue;
       ratings.push(Number(log[j].rating));
+      var bucket = modelBucket(log[j].attribution);
+      bucket.ratings++;
+      bucket.rating_total += Number(log[j].rating);
     }
   }
 
-  return { outcomes: outcomes, ratings: ratings };
+  Object.keys(byModel).forEach(function(id) {
+    var item = byModel[id];
+    item.evidence_count = item.outcomes + item.ratings;
+    item.avg_rating = item.ratings ? Math.round((item.rating_total / item.ratings) * 10) / 10 : null;
+    item.sufficient_evidence = item.evidence_count >= MIN_EVIDENCE;
+    delete item.rating_total;
+  });
+  return { outcomes: outcomes, ratings: ratings, by_model: byModel };
 }
 
 /**
@@ -243,6 +264,7 @@ function computeEvolutionMetrics(opts) {
       outcome_breakdown: outcomeBreakdown,
       ratings: signals.ratings.length,
       avg_rating: avgRating,
+      model_breakdown: signals.by_model,
       patches_proposed: personaPatches.length,
       patches_applied: appliedPatches.length,
       avg_signal: Math.round(avgSignal * 10) / 10,

package/dist/lib/feedback-submit.js

@@ -240,7 +240,7 @@ function askConsentQuestion() {
     rl.question(
       '\nShare anonymized persona feedback with analyzthis_design maintainers?\n'
       + '  Sends: persona, rating, outcome (shipped/revised/missed), task type,\n'
-      + '         tags, comment/correction, redacted output snippets\n'
+      + '         tags, redacted corrections; or text-free fixed-benchmark aggregates\n'
       + '  Does NOT send: project paths, repo names, emails, or API keys\n'
       + 'Continue? [y/N] ',
       (answer) => {
@@ -388,6 +388,53 @@ async function submitScores({ dryRun = false } = {}) {
   return { sent, rows };
 }
 
+/**
+ * Build text-free, fixed-benchmark calibration cells. Random install IDs are
+ * deduplication hints only; the server and maintainer must not treat them as identity.
+ */
+function buildCalibrationPayloads(report, cfg) {
+  if (!report || report.official_benchmark !== true || report.private_tasks === true) {
+    throw new Error('Only the package fixed benchmark can be shared. Private-task results stay local.');
+  }
+  const cells = Array.isArray(report.community_rows) ? report.community_rows : [];
+  return cells.map((cell) => ({
+    install_id: cfg.installId,
+    package_version: cfg.packageVersion,
+    benchmark_version: String(report.benchmark_version || ''),
+    validator_version: String(report.validator_version || ''),
+    judge_policy_version: String(report.judge_policy_version || ''),
+    prompt_hash: String(cell.prompt_hash || ''),
+    persona: String(cell.persona || ''),
+    effort: String(cell.effort || ''),
+    output_format: String(cell.output_format || ''),
+    model_id: String(cell.model_id || ''),
+    sample_count: Number(cell.sample_count || 0),
+    score_mean: Number(cell.score_mean || 0),
+    score_variance: Number(cell.score_variance || 0),
+    pass_rate: Number(cell.pass_rate || 0),
+    latency_ms: Number(cell.latency_ms || 0),
+    availability_rate: Number(cell.availability_rate || 0),
+    cost_usd: Number(cell.cost_usd || 0),
+  }));
+}
+
+async function submitCalibration(report, { dryRun = false, yes = false } = {}) {
+  const cfg = resolveSubmitConfig();
+  if (!cfg.enabled) throw new Error('Feedback submit is disabled.');
+  const rows = buildCalibrationPayloads(report, cfg);
+  if (!rows.length) return { submitted: 0, skipped: 'no fixed-benchmark cells' };
+  if (dryRun) return { submitted: 0, dryRun: true, rows, endpoint: cfg.url };
+  const consented = await ensureConsent({ yes });
+  if (!consented) return { submitted: 0, cancelled: true };
+  let sent = 0;
+  for (let i = 0; i < rows.length; i += MAX_ROWS_PER_REQUEST) {
+    const batch = rows.slice(i, i + MAX_ROWS_PER_REQUEST);
+    await postJson(cfg.url, {}, { kind: 'calibration', rows: batch });
+    sent += batch.length;
+  }
+  return { submitted: sent, endpoint: cfg.url };
+}
+
 module.exports = {
   anonymizeText,
   entryToSubmitPayload,
@@ -395,6 +442,8 @@ module.exports = {
   submitFeedback,
   submitScores,
   buildScorePayloads,
+  buildCalibrationPayloads,
+  submitCalibration,
   submitStatus,
   collectUnsentEntries,
   markEntriesSubmitted,

package/dist/lib/feedback.js

@@ -75,6 +75,11 @@ function recordFeedback(opts = {}) {
   if (!outputEntry) {
     throw new Error(`No output recorded for persona "${persona}" in this session yet.`);
   }
+  if (state.active_run && outputEntry.run_id !== state.active_run.id) {
+    const stale = new Error(`The "${persona}" output is from an older run. Run it again before recording feedback.`);
+    stale.code = 'STALE_OUTPUT';
+    throw stale;
+  }
 
   const entry = {
     id: crypto.randomBytes(8).toString('hex'),
@@ -86,6 +91,14 @@ function recordFeedback(opts = {}) {
     comment: String(comment).trim(),
     correction: String(correction).trim(),
     tags: tags.length ? tags : (satisfied ? ['positive'] : ['other']),
+    run_id: outputEntry.run_id || null,
+    attribution: outputEntry.attribution || {
+      provider: 'host',
+      model: 'unknown',
+      model_id: 'host/unknown',
+      effort: 'unknown',
+    },
+    quality: outputEntry.quality || null,
     original_output: typeof outputEntry.text === 'string'
       ? outputEntry.text.slice(0, 8000)
       : JSON.stringify(outputEntry).slice(0, 8000),
@@ -155,6 +168,8 @@ function exportCorrections({ persona, project, all = false, output, includePosit
       project_id: e.project_id,
       rating: e.rating,
       tags: e.tags,
+      run_id: e.run_id || null,
+      attribution: e.attribution || null,
       system_card: loadCard(e.persona),
       user: e.context?.task_map_summary || '',
       assistant_rejected: e.original_output,

package/dist/lib/lessons.js

@@ -82,6 +82,8 @@ function extractLessonsFromSession(state, personaId) {
 
   var lessons = [];
   var text = entry.text || '';
+  var attribution = entry.attribution || null;
+  var runId = entry.run_id || null;
 
   var fixesMatch = text.match(/Top\s*2\s*fixes:[\s\S]*?(?:\n\n|```|$)/i);
   if (fixesMatch) {
@@ -103,6 +105,8 @@ function extractLessonsFromSession(state, personaId) {
           session_id: state.project_id,
           extracted_at: new Date().toISOString(),
           citation: entry.citations ? entry.citations[0] : ''
+          ,attribution: attribution
+          ,run_id: runId
         });
       }
     }
@@ -127,6 +131,8 @@ function extractLessonsFromSession(state, personaId) {
         session_id: state.project_id,
         extracted_at: new Date().toISOString(),
         citation: ''
+        ,attribution: attribution
+        ,run_id: runId
       });
       break;
     }
@@ -147,6 +153,8 @@ function extractLessonsFromSession(state, personaId) {
         session_id: state.project_id,
         extracted_at: new Date().toISOString(),
         citation: ''
+        ,attribution: attribution
+        ,run_id: runId
       });
     }
   }

package/dist/lib/mcp-server.js

@@ -72,7 +72,7 @@ var TOOLS = [
   },
   {
     name: 'analyzthis_zara',
-    description: 'Zara — Delight moments. Identifies exactly ONE structural or surface delight moment in a design. Covers first impressions, onboarding flows, empty states, peak moments, and once-ever experiences. Use after the core critique is done.',
+    description: 'Zara — Delight moments, and scout for UI image boards. Identifies exactly ONE structural or surface delight moment. On a UI board she browses real shipped screens, picks 3-5 frames, and re-scouts if the jury skips. Use after the core critique, or when the user wants a UI image board.',
     inputSchema: {
       type: 'object',
       properties: {
@@ -208,15 +208,24 @@ var TOOLS = [
   },
   {
     name: 'analyzthis_mood_board',
-    description: 'Mood Board — Visual direction. Collects web references + design-system patterns, tags them by style/mood/surface, and runs team deliberation (Arjun, Meera, Priya, Zara, Noor) using the UX Honeycomb matrix. Use for setting visual direction before designing.',
+    description: 'Mood Board or UI image board. Mood: tagged URLs + team deliberation. UI: Zara scouts 3-5 real shipped screens, then Arjun/Noor/Priya/Meera jury. She re-scouts if they skip (max 3 rounds). Use for visual direction before designing.',
     inputSchema: {
       type: 'object',
       properties: {
         task: { type: 'string', description: 'Visual direction brief (e.g., "B2B fintech dashboard, trustworthy, high-contrast, data-dense")' },
-        urls: { type: 'array', items: { type: 'string' }, description: 'Web reference URLs to include' },
-        auto: { type: 'boolean', description: 'Auto-collect references' },
+        kind: { type: 'string', enum: ['mood', 'ui'], description: 'mood = tagged URLs (default). ui = Zara image-board scout.' },
+        action: { type: 'string', enum: ['create', 'frames', 'jury', 'verdict'], description: 'create (default), frames (save Zara picks), jury (critique prompt), verdict (SHIP/REVISE/BLOCK after jury)' },
+        verdict: { type: 'string', enum: ['SHIP', 'REVISE', 'BLOCK'], description: 'Jury verdict (action=verdict)' },
+        summary: { type: 'string', description: 'Jury because-lines (action=verdict). Sent back to Zara if they skip.' },
+        board: { type: 'string', description: 'Board id (frames and jury)' },
+        urls: { type: 'array', items: { type: 'string' }, description: 'Web reference URLs to include (mood boards)' },
+        url: { type: 'string', description: 'One frame URL (ui boards, action=frames)' },
+        title: { type: 'string', description: 'Frame title' },
+        steal: { type: 'string', description: 'One thing to take from this frame' },
+        refuse: { type: 'string', description: 'One thing we will not copy' },
+        peak: { type: 'string', description: 'The first-impression this frame proves' },
+        auto: { type: 'boolean', description: 'Auto-collect references (mood boards only)' },
       },
-      required: ['task'],
     },
   },
   {
@@ -469,6 +478,111 @@ function handleCombinationPass(skillId, args) {
 function handleMoodBoard(args) {
   var skill = readSkill('mood-board');
   var task = args.task || '';
+  var kind = args.kind === 'ui' ? 'ui' : 'mood';
+  var action = args.action || 'create';
+  var mb = require('./moodboard');
+
+  if (action === 'frames') {
+    try {
+      var added = mb.addFrames({
+        boardId: args.board,
+        frames: args.frames || [{
+          url: args.url,
+          title: args.title,
+          steal: args.steal,
+          refuse: args.refuse,
+          peak: args.peak,
+        }],
+      });
+      return {
+        result: 'Saved. ' + added.board.frames.length + ' frame(s). Next: action=jury on board ' + added.board.board_id,
+        board_id: added.board.board_id,
+        scout: added.board.scout,
+      };
+    } catch (e) {
+      return { error: e.message };
+    }
+  }
+
+  if (action === 'jury') {
+    try {
+      var juryBoard = mb.getBoard({ boardId: args.board });
+      if (!juryBoard.frames || !juryBoard.frames.length) {
+        return {
+          error: 'NEED_SCOUT',
+          board_id: juryBoard.board_id,
+          scout: juryBoard.scout,
+          prompt: 'Zara has not scouted yet.\n\n' + ((juryBoard.scout && juryBoard.scout.brief) || ''),
+        };
+      }
+      var frameLines = juryBoard.frames.map(function(f, idx) {
+        return (idx + 1) + '. ' + (f.title || 'Frame') + ' — ' + (f.url || '') +
+          '\n   Steal: ' + (f.steal || '') +
+          '\n   Refuse: ' + (f.refuse || '') +
+          '\n   Peak: ' + (f.peak || '');
+      }).join('\n');
+      var juryPrompt = 'You are the UI image-board jury: Arjun, Noor, Priya, Meera. Zara does not vote.\n\n' +
+        'Job: ' + (juryBoard.task || '') + '\n\n' +
+        'Frames:\n' + frameLines + '\n\n' +
+        'KEEP or SKIP each frame with one because-sentence. Rank the best 2-3. Verdict SHIP only if the set fits the job. REVISE or BLOCK sends Zara to scout again.\n' +
+        'Do not reward cinematic marketing motion on a daily working surface.\n\n' +
+        'Then call analyzthis_mood_board with action=verdict, board=' + juryBoard.board_id +
+        ', verdict=SHIP|REVISE|BLOCK, and summary=the because-lines.';
+      return { prompt: juryPrompt, board_id: juryBoard.board_id, scout: juryBoard.scout, frames: juryBoard.frames };
+    } catch (e) {
+      return { error: e.message };
+    }
+  }
+
+  if (action === 'verdict') {
+    try {
+      var judged = mb.recordJuryVerdict({
+        boardId: args.board,
+        verdict: args.verdict,
+        summary: args.summary,
+      });
+      var scout = judged.board.scout || {};
+      if (scout.status === 'awaiting_scout') {
+        return {
+          result: 'Jury skipped. Zara scouts again (round ' + scout.round + ').',
+          board_id: judged.board.board_id,
+          scout: scout,
+          prompt: 'You are Zara on a Scout Pass. Search and open real pages. Do not invent URLs.\n\n' + scout.brief +
+            '\n\nBoard id: ' + judged.board.board_id + '\nAfter 3-5 new frames, call action=frames, then action=jury.',
+        };
+      }
+      if (scout.status === 'raj') {
+        return {
+          result: 'Max scout rounds reached. Raj or the designer picks from the frames on this board.',
+          board_id: judged.board.board_id,
+          scout: scout,
+        };
+      }
+      return {
+        result: 'Jury SHIP. Board is done. User still /accept on the notes.',
+        board_id: judged.board.board_id,
+        scout: scout,
+      };
+    } catch (e) {
+      return { error: e.message };
+    }
+  }
+
+  if (kind === 'ui') {
+    if (!task) return { error: 'task is required to open a UI image board' };
+    try {
+      var created = mb.buildMoodBoard({ task: task, kind: 'ui', discover: false });
+      var prompt = 'You are Zara on a Scout Pass. Search and open real pages. Do not invent URLs.\n\n' +
+        created.board.scout.brief + '\n\n' +
+        'Board id: ' + created.board.board_id + '\n' +
+        'After 3-5 frames, call analyzthis_mood_board again with action=frames, board=' + created.board.board_id +
+        ', and url/title/steal/refuse/peak. Then action=jury.\n';
+      return { prompt: prompt, board_id: created.board.board_id, scout: created.board.scout, task: task };
+    } catch (e) {
+      return { error: e.message };
+    }
+  }
+
   var urls = (args.urls || []).join('\n');
   var prompt = 'Build a mood board.\n\n' +
     (skill ? skill.slice(0, 3000) : '') + '\n\n' +

package/dist/lib/model-policy.js

@@ -0,0 +1,174 @@
+'use strict';
+
+/**
+ * Shared model preference resolver for chunked and unchunked execution.
+ * Effort/gate constraints are established by the caller before preferences.
+ */
+
+var fs = require('fs');
+var path = require('path');
+var os = require('os');
+var crypto = require('crypto');
+var registry = require('./model-registry');
+var provider = require('./provider');
+var platforms = require('./platforms');
+var outputQuality = require('./output-quality');
+
+var PACKAGE_ROOT = platforms.resolvePackageRoot(__dirname);
+var DEFAULT_LOCAL_FILE = path.join(os.homedir(), '.analyzthis_design', 'calibration.json');
+var GLOBAL_FILE = path.join(PACKAGE_ROOT, 'agents', 'model-policy.json');
+
+function readJson(file) {
+  if (!file || !fs.existsSync(file)) return {};
+  try { return JSON.parse(fs.readFileSync(file, 'utf8')); }
+  catch (e) { return {}; }
+}
+
+function localFile() {
+  return process.env.ANALYZTHIS_CALIBRATION_FILE || DEFAULT_LOCAL_FILE;
+}
+
+function promptHash(persona) {
+  var manifestPath = path.join(PACKAGE_ROOT, 'agents', 'manifests', persona + '.json');
+  var manifest = readJson(manifestPath);
+  var parts = [];
+  [manifest.system_card, manifest.system_skill].forEach(function(relative) {
+    if (!relative) return;
+    var file = path.join(PACKAGE_ROOT, relative);
+    if (fs.existsSync(file)) parts.push(fs.readFileSync(file));
+  });
+  return crypto.createHash('sha256').update(Buffer.concat(parts)).digest('hex').slice(0, 16);
+}
+
+function calibrationContract() {
+  var file = path.join(PACKAGE_ROOT, 'agents', 'calibration-benchmark.json');
+  var benchmark = readJson(file);
+  return {
+    version: benchmark.version,
+    judge_policy_version: benchmark.judge_version,
+    hash: Object.keys(benchmark).length
+      ? crypto.createHash('sha256').update(JSON.stringify(benchmark)).digest('hex').slice(0, 16)
+      : null,
+  };
+}
+
+function assignmentFrom(policy, persona, effort) {
+  var personas = policy.personas || policy.assignments || {};
+  return personas[persona] && personas[persona][effort];
+}
+
+function eligible(spec, effort) {
+  spec = registry.normalizeSpec(spec);
+  if (!spec.provider || !spec.model || registry.isExpired(spec)) return false;
+  if (spec.effort && spec.effort.indexOf(effort) === -1) return false;
+  if (spec.provider !== 'host' && !provider.hasKey(spec.provider)) return false;
+  return true;
+}
+
+function validWinner(winner, persona, effort, requireContract) {
+  if (!winner || !eligible(winner, effort)) return false;
+  if (requireContract) {
+    var hasJudge = winner.judge_policy_version != null || winner.judge_version != null;
+    if (!winner.prompt_hash || winner.validator_version == null ||
+        winner.benchmark_version == null || !winner.benchmark_hash ||
+        !hasJudge || !winner.expires_at) return false;
+  }
+  if (winner.prompt_hash && winner.prompt_hash !== promptHash(persona)) return false;
+  if (winner.validator_version != null && Number(winner.validator_version) !== outputQuality.VERSION) return false;
+  var contract = calibrationContract();
+  if (winner.benchmark_version != null && winner.benchmark_version !== contract.version) return false;
+  if (winner.benchmark_hash && winner.benchmark_hash !== contract.hash) return false;
+  var judgeVersion = winner.judge_policy_version != null ? winner.judge_policy_version : winner.judge_version;
+  if (judgeVersion != null && judgeVersion !== contract.judge_policy_version) return false;
+  return true;
+}
+
+function resolveAssignment(opts) {
+  opts = opts || {};
+  var persona = opts.persona || 'general';
+  var effort = opts.effort || 'standard';
+  var config = opts.config || {};
+  var candidates = [];
+
+  if (opts.explicitProvider || opts.explicitModel) {
+    var inferred = opts.explicitProvider;
+    if (!inferred && opts.explicitModel) {
+      var known = registry.MODELS.find(function(item) { return item.model === opts.explicitModel; });
+      inferred = known && known.provider;
+    }
+    candidates.push({
+      source: 'explicit',
+      value: { provider: inferred, model: opts.explicitModel },
+      strict: true,
+    });
+  }
+
+  var pinned = assignmentFrom(config.model_policy || {}, persona, effort);
+  if (!pinned && config.orchestrator && config.orchestrator.provider &&
+      config.orchestrator.provider !== 'auto' && config.orchestrator.model) {
+    pinned = { provider: config.orchestrator.provider, model: config.orchestrator.model };
+  }
+  if (pinned) candidates.push({ source: 'user_config', value: pinned, strict: false });
+  candidates.push({ source: 'local_calibration', value: assignmentFrom(readJson(localFile()), persona, effort) });
+  candidates.push({ source: 'package_policy', value: assignmentFrom(readJson(GLOBAL_FILE), persona, effort) });
+
+  for (var i = 0; i < candidates.length; i++) {
+    var candidate = candidates[i];
+    if (!candidate.value) continue;
+    var value = registry.normalizeSpec(candidate.value);
+    var requireContract = candidate.source === 'local_calibration' || candidate.source === 'package_policy';
+    if (validWinner(value, persona, effort, requireContract)) {
+      return { spec: value, source: candidate.source, prompt_hash: promptHash(persona) };
+    }
+    if (candidate.strict) {
+      var error = new Error('Requested model is unavailable or not eligible for effort=' + effort);
+      error.code = 'INELIGIBLE_MODEL';
+      throw error;
+    }
+  }
+  return null;
+}
+
+function prioritizePool(pool, opts) {
+  opts = opts || {};
+  if (opts.explicitProvider && !opts.explicitModel) {
+    var providerOnly = pool.filter(function(item) {
+      return item.provider === opts.explicitProvider;
+    });
+    if (!providerOnly.length) {
+      var providerError = new Error('No eligible model for requested provider: ' + opts.explicitProvider);
+      providerError.code = 'INELIGIBLE_MODEL';
+      throw providerError;
+    }
+    return { pool: providerOnly, policy: { source: 'explicit_provider' } };
+  }
+  var resolved = resolveAssignment(opts);
+  if (!resolved) return { pool: pool, policy: null };
+  var wanted = registry.id(resolved.spec);
+  var index = pool.findIndex(function(item) {
+    return registry.id(item) === wanted;
+  });
+  if (index === -1) {
+    if (resolved.source === 'explicit' || resolved.source === 'user_config') {
+      var error = new Error('Requested model is not in the available model pool: ' + wanted);
+      error.code = 'MODEL_NOT_IN_POOL';
+      throw error;
+    }
+    return { pool: pool, policy: null };
+  }
+  var ordered = pool.slice();
+  var selected = ordered.splice(index, 1)[0];
+  ordered.unshift(selected);
+  return { pool: ordered, policy: resolved };
+}
+
+module.exports = {
+  VERSION: 1,
+  GLOBAL_FILE: GLOBAL_FILE,
+  localFile: localFile,
+  promptHash: promptHash,
+  calibrationContract: calibrationContract,
+  eligible: eligible,
+  resolveAssignment: resolveAssignment,
+  prioritizePool: prioritizePool,
+};

package/dist/lib/model-registry.js

@@ -0,0 +1,71 @@
+'use strict';
+
+/**
+ * Canonical model metadata. Prices are USD per one million tokens.
+ * User-defined pool entries remain supported through normalizeSpec().
+ */
+
+var MODELS = [
+  { provider: 'groq', model: 'llama-3.1-8b-instant', input_per_m: 0.05, output_per_m: 0.08, effort: ['trivial', 'standard'], context: 131072, key_env: 'GROQ_API_KEY' },
+  { provider: 'groq', model: 'mixtral-8x7b-32768', input_per_m: 0.24, output_per_m: 0.24, effort: ['trivial', 'standard', 'hard'], context: 32768, key_env: 'GROQ_API_KEY' },
+  { provider: 'google', model: 'gemini-1.5-flash', input_per_m: 0.075, output_per_m: 0.30, effort: ['trivial', 'standard', 'hard'], context: 128000, key_env: 'GEMINI_API_KEY' },
+  { provider: 'google', model: 'gemini-1.5-flash-8b', input_per_m: 0.0375, output_per_m: 0.15, effort: ['trivial', 'standard'], context: 128000, key_env: 'GEMINI_API_KEY' },
+  { provider: 'google', model: 'gemini-2.5-flash', input_per_m: 0.30, output_per_m: 2.50, effort: ['trivial', 'standard', 'hard'], context: 1000000, key_env: 'GEMINI_API_KEY' },
+  { provider: 'deepseek', model: 'deepseek-chat', input_per_m: 0.07, output_per_m: 0.27, effort: ['trivial', 'standard', 'hard'], context: 64000, key_env: 'DEEPSEEK_API_KEY' },
+  { provider: 'openrouter', model: 'meta-llama/llama-3.1-8b-instruct:free', input_per_m: 0, output_per_m: 0, effort: ['trivial', 'standard'], context: 131072, key_env: 'OPENROUTER_API_KEY' },
+  { provider: 'together', model: 'meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo', input_per_m: 0.18, output_per_m: 0.18, effort: ['trivial', 'standard'], context: 8192, key_env: 'TOGETHER_API_KEY' },
+  { provider: 'openai', model: 'gpt-4o-mini', input_per_m: 0.15, output_per_m: 0.60, effort: ['trivial', 'standard'], context: 128000, key_env: 'OPENAI_API_KEY' },
+  { provider: 'anthropic', model: 'claude-sonnet-4-20250514', input_per_m: 3, output_per_m: 15, effort: ['standard', 'hard'], context: 200000, key_env: 'ANTHROPIC_API_KEY' },
+];
+
+function id(spec) {
+  return String(spec.provider || '') + '/' + String(spec.model || '');
+}
+
+function normalizeSpec(spec) {
+  spec = Object.assign({}, spec || {});
+  var canonical = MODELS.find(function(item) {
+    return item.provider === spec.provider && item.model === spec.model;
+  }) || {};
+  var merged = Object.assign({}, canonical, spec);
+  if (merged.input_per_m == null && merged.cost != null) {
+    // v2.5.2 scalar costs were stored in per-1K units despite their comment.
+    merged.input_per_m = Number(merged.cost) * 1000;
+  }
+  if (merged.output_per_m == null && merged.cost != null) {
+    merged.output_per_m = Number(merged.cost) * 1000;
+  }
+  merged.input_per_m = Number(merged.input_per_m || 0);
+  merged.output_per_m = Number(merged.output_per_m || 0);
+  merged.cost = Math.max(merged.input_per_m, merged.output_per_m) / 1000;
+  merged.id = id(merged);
+  return merged;
+}
+
+function estimateCost(spec, inputTokens, outputTokens) {
+  spec = normalizeSpec(spec);
+  return (Number(inputTokens || 0) / 1e6) * spec.input_per_m +
+    (Number(outputTokens || 0) / 1e6) * spec.output_per_m;
+}
+
+function find(provider, model) {
+  var found = MODELS.find(function(item) {
+    return item.provider === provider && item.model === model;
+  });
+  return found ? normalizeSpec(found) : null;
+}
+
+function isExpired(spec, now) {
+  if (!spec || !spec.expires_at) return false;
+  return new Date(spec.expires_at).getTime() <= (now || Date.now());
+}
+
+module.exports = {
+  VERSION: 1,
+  MODELS: MODELS,
+  id: id,
+  find: find,
+  normalizeSpec: normalizeSpec,
+  estimateCost: estimateCost,
+  isExpired: isExpired,
+};