analyzthis_design 2.5.1 → 2.5.2

package/dist/lib/chunk-executor.js

@@ -14,6 +14,7 @@ var chunkModels = require('./chunk-models');
 var chunkRouter = require('./chunk-router');
 var telemetry = require('./chunk-telemetry');
 var referencePack = require('./reference-pack');
+var outputQuality = require('./output-quality');
 
 function buildChunkPrompt(chunk, priorResults, contextPack) {
   var priorContext = '';
@@ -90,6 +91,9 @@ async function executeChunk(opts) {
   var callLlmFn = opts.callLlmFn;
   var attempt = 0;
   var maxAttempts = opts.maxAttempts || 3;
+  var qualityFailures = 0;
+  var maxQualityFailures = opts.maxQualityFailures == null ? 1 : Number(opts.maxQualityFailures);
+  var outputFormat = chunk.output_schema || 'generic';
 
   if (!callLlmFn) {
     var orchestrator = require('./orchestrator/run');
@@ -112,8 +116,12 @@ async function executeChunk(opts) {
       effort: chunk.effort || 'standard',
       chunkType: chunk.id + '/' + chunk.persona,
       persona: chunk.persona,
+      taskType: chunk.id,
+      outputFormat: outputFormat,
       budget: budget,
       config: config,
+      explicitProvider: opts.explicitProvider,
+      explicitModel: opts.explicitModel,
     });
     ranked = resolved.ranked;
   } catch (e) {
@@ -154,27 +162,51 @@ async function executeChunk(opts) {
 
       var inTok = Math.ceil((prompts.system.length + prompts.user.length) / 4);
       var outTok = Math.ceil(text.length / 4);
+      var quality = outputQuality.validateOutput(text, {
+        persona: chunk.persona,
+        outputFormat: outputFormat,
+      });
 
       telemetry.record({
+        scope_version: 1,
         chunk_id: chunk.id,
         persona: chunk.persona,
+        task_type: chunk.id,
+        output_format: outputFormat,
         model: chunkModels.formatModelName(model),
         provider: model.provider,
         effort: chunk.effort || 'standard',
         input_tokens: inTok,
         output_tokens: outTok,
         cost: chunkModels.estimateCost(model, inTok, outTok),
-        success: true,
+        transport_success: true,
+        quality_pass: quality.pass,
+        quality_score: quality.score,
+        validator_version: quality.version,
+        success: quality.pass,
         attempts: attempt,
         at: new Date().toISOString(),
       });
 
+      if (!quality.pass) {
+        qualityFailures++;
+        lastError = 'Output quality failed: ' + quality.issues.map(function(item) {
+          return item.code;
+        }).join(', ');
+        if (qualityFailures > maxQualityFailures) break;
+        modelIndex++;
+        continue;
+      }
+
       return {
         chunk_id: chunk.id,
         persona: chunk.persona,
         goal: chunk.goal,
+        effort: chunk.effort || 'standard',
+        output_format: outputFormat,
         model_used: { provider: model.provider, model: model.model, cost: model.cost },
         output: text,
+        full_prompt: prompts,
         structured_output: parseStructured(text, chunk.output_schema),
         tokens: { input: inTok, output: outTok },
         cost: chunkModels.estimateCost(model, inTok, outTok),
@@ -182,16 +214,23 @@ async function executeChunk(opts) {
         attempts: attempt,
         cache_hit: cacheHit,
         references: (refPack && refPack.citations) || [],
+        quality: quality,
         success: true,
       };
     } catch (e) {
       lastError = e.message;
       telemetry.record({
+        scope_version: 1,
         chunk_id: chunk.id,
         persona: chunk.persona,
+        task_type: chunk.id,
+        output_format: outputFormat,
         model: chunkModels.formatModelName(model),
         provider: model.provider,
         effort: chunk.effort || 'standard',
+        transport_success: false,
+        quality_pass: null,
+        failure_kind: outputQuality.classifyError(e),
         success: false,
         error: e.message,
         attempts: attempt,
@@ -208,6 +247,7 @@ async function executeChunk(opts) {
     success: false,
     error: lastError || 'All chunk models failed',
     attempts: attempt,
+    quality_failures: qualityFailures,
     output: '',
   };
 }

package/dist/lib/chunk-models.js

@@ -14,6 +14,7 @@ var fs = require('fs');
 var path = require('path');
 var os = require('os');
 var http = require('http');
+var modelRegistry = require('./model-registry');
 
 var CONFIG_FILE = path.join(os.homedir(), '.analyzthis_design', 'config.json');
 
@@ -29,20 +30,7 @@ function hasEnv(name) {
 
 // Curated cloud models. Prices are estimates (USD per 1M tokens input/output).
 // The router treats cost=0 as free; anything >0 as cheap/paid.
-var DEFAULT_CLOUD_POOL = [
-  // Free-ish / very cheap with user key
-  { provider: 'groq', model: 'llama-3.1-8b-instant', cost: 0.00005, effort: ['trivial', 'standard'], context: 131072, key_env: 'GROQ_API_KEY' },
-  { provider: 'groq', model: 'mixtral-8x7b-32768', cost: 0.00024, effort: ['trivial', 'standard', 'hard'], context: 32768, key_env: 'GROQ_API_KEY' },
-  { provider: 'google', model: 'gemini-1.5-flash', cost: 0.000075, effort: ['trivial', 'standard', 'hard'], context: 128000, key_env: 'GEMINI_API_KEY' },
-  { provider: 'google', model: 'gemini-1.5-flash-8b', cost: 0.0000375, effort: ['trivial', 'standard'], context: 128000, key_env: 'GEMINI_API_KEY' },
-  { provider: 'deepseek', model: 'deepseek-chat', cost: 0.00007, effort: ['trivial', 'standard', 'hard'], context: 64000, key_env: 'DEEPSEEK_API_KEY' },
-  { provider: 'openrouter', model: 'meta-llama/llama-3.1-8b-instruct:free', cost: 0, effort: ['trivial', 'standard'], context: 131072, key_env: 'OPENROUTER_API_KEY' },
-  { provider: 'together', model: 'meta-llama/Meta-Llama-3.1-8B-Instruct-Turbo', cost: 0.00018, effort: ['trivial', 'standard'], context: 8192, key_env: 'TOGETHER_API_KEY' },
-  // Paid but cheap fallback
-  { provider: 'openai', model: 'gpt-4o-mini', cost: 0.00015, effort: ['trivial', 'standard'], context: 128000, key_env: 'OPENAI_API_KEY' },
-  // Frontier chunk fallback (only if budget allows)
-  { provider: 'anthropic', model: 'claude-sonnet-4-20250514', cost: 0.003, effort: ['standard', 'hard'], context: 200000, key_env: 'ANTHROPIC_API_KEY' },
-];
+var DEFAULT_CLOUD_POOL = modelRegistry.MODELS.map(modelRegistry.normalizeSpec);
 
 // Recommended Ollama models for chunk tasks, ordered by capability/cost trade-off.
 var DEFAULT_OLLAMA_MODELS = [
@@ -124,7 +112,7 @@ async function discoverPool(opts) {
   }
 
   var userPool = getUserPool(config);
-  pool = pool.concat(userPool || DEFAULT_CLOUD_POOL);
+  pool = pool.concat((userPool || DEFAULT_CLOUD_POOL).map(modelRegistry.normalizeSpec));
 
   return pool;
 }
@@ -208,9 +196,7 @@ function formatModelName(spec) {
 }
 
 function estimateCost(spec, inputTokens, outputTokens) {
-  var cost = spec.cost || 0;
-  if (cost <= 0) return 0;
-  return (inputTokens / 1e6 + outputTokens / 1e6) * cost;
+  return modelRegistry.estimateCost(spec, inputTokens, outputTokens);
 }
 
 module.exports = {

package/dist/lib/chunk-router.js

@@ -12,9 +12,10 @@
 
 var chunkModels = require('./chunk-models');
 var telemetry = require('./chunk-telemetry');
+var modelPolicy = require('./model-policy');
 
-function applyTelemetryPenalty(pool, chunkType) {
-  var stats = telemetry.getStatsForChunkType(chunkType);
+function applyTelemetryPenalty(pool, chunkType, scope) {
+  var stats = telemetry.getStatsForChunkType(chunkType, scope);
   if (!stats || !stats.length) return pool;
 
   var penalized = [];
@@ -23,11 +24,12 @@ function applyTelemetryPenalty(pool, chunkType) {
     var name = chunkModels.formatModelName(spec);
     var record = stats.find(function(s) { return s.model === name; });
     var penalty = 0;
-    if (record && record.attempts >= 3) {
-      // Deprioritize if success rate is low.
-      var successRate = record.successful / record.attempts;
+    if (record && record.quality_attempts >= 3) {
+      // Rate limits are availability failures and never lower a model's quality score.
+      var successRate = record.quality_successful / record.quality_attempts;
       if (successRate < 0.5) penalty += 0.01;
       if (successRate < 0.25) penalty += 0.02;
+      if (record.confidence === 'legacy') penalty *= 0.25;
     }
     penalized.push(Object.assign({}, spec, { effective_cost: (spec.cost || 0) + penalty }));
   }
@@ -48,7 +50,20 @@ async function resolveChunkModel(opts) {
 
   var pool = await chunkModels.discoverPool({ config: config });
   var filtered = chunkModels.filterPool(pool, { effort: effort, budget: budget });
-  var ranked = applyTelemetryPenalty(filtered, chunkType);
+  var ranked = applyTelemetryPenalty(filtered, chunkType, {
+    persona: opts.persona,
+    effort: effort,
+    taskType: opts.taskType || chunkType,
+    outputFormat: opts.outputFormat,
+  });
+  var prioritized = modelPolicy.prioritizePool(ranked, {
+    persona: opts.persona,
+    effort: effort,
+    config: config,
+    explicitProvider: opts.explicitProvider,
+    explicitModel: opts.explicitModel,
+  });
+  ranked = prioritized.pool;
 
   if (!ranked.length) {
     throw new Error('No chunk model available for effort=' + effort + ' budget=' + budget);
@@ -57,6 +72,7 @@ async function resolveChunkModel(opts) {
   return {
     ranked: ranked,
     selected: ranked[0],
+    policy: prioritized.policy,
   };
 }
 

package/dist/lib/chunk-run.js

@@ -17,12 +17,15 @@
 var fs = require('fs');
 var os = require('os');
 var path = require('path');
+var crypto = require('crypto');
 
 var session = require('./session');
 var planner = require('./chunk-planner');
 var executor = require('./chunk-executor');
 var synthesis = require('./chunk-synthesis');
 var chunkModels = require('./chunk-models');
+var modelPolicy = require('./model-policy');
+var outputQuality = require('./output-quality');
 
 var CONFIG_FILE = path.join(os.homedir(), '.analyzthis_design', 'config.json');
 
@@ -47,6 +50,14 @@ async function runChunked(opts) {
   if (!task) throw new Error('--task is required');
 
   var state = session.show({ project: projectId }) || session.init({ project: projectId });
+  var runId = 'chunk-' + Date.now() + '-' + crypto.randomBytes(4).toString('hex');
+  state = session.update({
+    project: projectId,
+    patch: {
+      active_run: { id: runId, mode: 'chunked', at: new Date().toISOString() },
+      persona_outputs: {},
+    },
+  });
 
   var planResult;
   try {
@@ -106,6 +117,8 @@ async function runChunked(opts) {
       config: config,
       budget: budget,
       callLlmFn: callLlmFn,
+      explicitProvider: opts.provider,
+      explicitModel: opts.model,
     });
 
     results.push(result);
@@ -140,6 +153,7 @@ async function runChunked(opts) {
   }
 
   var chunkRun = {
+    run_id: runId,
     plan: planResult.plan,
     planner_model: planResult.planner_model,
     planner_warning: planResult.planner_warning,
@@ -154,10 +168,45 @@ async function runChunked(opts) {
     mode: sequential ? 'sequential' : 'parallel',
   };
 
+  // Default runs must feed the same feedback/evolution path as unchunked runs.
+  var personaOutputs = {};
+  var fullPrompts = {};
+  var structuredOutputs = {};
+  results.forEach(function(result) {
+    if (!result.persona || !result.success) return;
+    var model = result.model_used || {};
+    personaOutputs[result.persona] = {
+      text: result.output,
+      at: new Date().toISOString(),
+      accepted: null,
+      source: 'chunked',
+      run_id: runId,
+      structured_output: result.structured_output,
+      quality: result.quality,
+      attribution: {
+        provider: model.provider || 'unknown',
+        model: model.model || 'unknown',
+        model_id: model.provider && model.model ? chunkModels.formatModelName(model) : 'unknown/unknown',
+        effort: result.effort || 'standard',
+        policy_version: modelPolicy.VERSION,
+        prompt_hash: modelPolicy.promptHash(result.persona),
+        validator_version: outputQuality.VERSION,
+      },
+    };
+    if (result.full_prompt) fullPrompts[result.persona] = result.full_prompt;
+    if (result.structured_output) structuredOutputs[result.persona] = result.structured_output;
+  });
+
   var final = session.update({
     project: projectId,
     patch: {
       chunk_run: chunkRun,
+      active_run: { id: runId, mode: 'chunked', at: new Date().toISOString() },
+      persona_outputs: personaOutputs,
+      full_prompts: fullPrompts,
+      structured_outputs: structuredOutputs,
+      synthesis: syn.composite || syn,
+      synthesis_markdown: syn.markdown || '',
       task_type: state.task_type || 'chunked_run',
       mode: 'assess_only',
       digest: Object.assign({}, state.digest || {}, {
@@ -178,8 +227,13 @@ async function runChunked(opts) {
         effort_log: results.map(function(r) {
           return {
             persona: r.persona,
-            effort: r.chunk ? r.chunk.effort : 'standard',
+            effort: r.effort || 'standard',
+            provider: r.model_used ? r.model_used.provider : null,
             model: r.model_used ? chunkModels.formatModelName(r.model_used) : null,
+            model_id: r.model_used ? chunkModels.formatModelName(r.model_used) : null,
+            input_tokens: r.tokens ? r.tokens.input : 0,
+            output_tokens: r.tokens ? r.tokens.output : 0,
+            run_id: runId,
             scoped_mode: null,
           };
         }),

package/dist/lib/chunk-synthesis.js

@@ -13,6 +13,7 @@
 var chunkModels = require('./chunk-models');
 var chunkRouter = require('./chunk-router');
 var synthesis = require('./synthesis');
+var outputQuality = require('./output-quality');
 
 function buildSynthesisPrompt(plan, results, contextPack) {
   var lines = [
@@ -122,6 +123,9 @@ async function synthesize(opts) {
     var resolved = await chunkRouter.resolveChunkModel({
       effort: 'hard',
       chunkType: 'synthesis',
+      persona: synChunk.persona || 'raj',
+      taskType: 'synthesis',
+      outputFormat: 'synthesis',
       budget: budget,
       config: config,
     });
@@ -153,8 +157,19 @@ async function synthesize(opts) {
 
   var inTok = Math.ceil((prompts.system.length + prompts.user.length) / 4);
   var outTok = Math.ceil(text.length / 4);
-
-  var syn = synthesis.buildSynthesis ? synthesis.buildSynthesis(successful) : null;
+  var quality = outputQuality.validateOutput(text, {
+    persona: synChunk.persona || 'raj',
+    outputFormat: 'synthesis',
+  });
+
+  var personaOutputs = {};
+  successful.forEach(function(result) {
+    if (result.persona) personaOutputs[result.persona] = {
+      text: result.output,
+      structured_output: result.structured_output,
+    };
+  });
+  var syn = quality.pass && synthesis.buildSynthesis ? synthesis.buildSynthesis(personaOutputs) : null;
   if (!syn) syn = fallbackSynthesis(successful);
 
   return {
@@ -169,6 +184,7 @@ async function synthesize(opts) {
     premise_challenge: extractPremiseCheck(text),
     conflict_resolutions: extractConflictResolutions(text),
     raw_synthesis: text,
+    quality: quality,
     tokens: { input: inTok, output: outTok },
     cost: chunkModels.estimateCost(model, inTok, outTok),
   };

package/dist/lib/chunk-telemetry.js

@@ -13,31 +13,37 @@ var fs = require('fs');
 var path = require('path');
 var os = require('os');
 
-var TELEMETRY_FILE = path.join(os.homedir(), '.analyzthis_design', 'chunk-telemetry.jsonl');
+var DEFAULT_TELEMETRY_FILE = path.join(os.homedir(), '.analyzthis_design', 'chunk-telemetry.jsonl');
 var MAX_LINES = 10000;
 
+function telemetryFile() {
+  return process.env.ANALYZTHIS_TELEMETRY_FILE || DEFAULT_TELEMETRY_FILE;
+}
+
 function ensureDir() {
-  fs.mkdirSync(path.dirname(TELEMETRY_FILE), { recursive: true });
+  fs.mkdirSync(path.dirname(telemetryFile()), { recursive: true });
 }
 
 function loadLines() {
-  if (!fs.existsSync(TELEMETRY_FILE)) return [];
+  var file = telemetryFile();
+  if (!fs.existsSync(file)) return [];
   try {
-    var text = fs.readFileSync(TELEMETRY_FILE, 'utf8');
+    var text = fs.readFileSync(file, 'utf8');
     return text.trim().split('\n').filter(function(l) { return l.trim(); });
   } catch (e) { return []; }
 }
 
 function append(record) {
   ensureDir();
+  var file = telemetryFile();
   var line = JSON.stringify(record);
-  fs.appendFileSync(TELEMETRY_FILE, line + '\n');
+  fs.appendFileSync(file, line + '\n');
 
   // Simple rotation: if file gets too large, keep last half.
   var lines = loadLines();
   if (lines.length > MAX_LINES) {
     var keep = lines.slice(Math.floor(MAX_LINES / 2));
-    fs.writeFileSync(TELEMETRY_FILE, keep.join('\n') + '\n');
+    fs.writeFileSync(file, keep.join('\n') + '\n');
   }
 }
 
@@ -48,23 +54,76 @@ function record(record) {
   append(r);
 }
 
-function getStatsForChunkType(chunkType) {
-  var lines = loadLines();
+function matchesScope(record, scope) {
+  if (!record.scope_version) return false;
+  if (scope.persona && record.persona !== scope.persona) return false;
+  if (scope.effort && record.effort !== scope.effort) return false;
+  if (scope.task_type && record.task_type !== scope.task_type) return false;
+  if (scope.output_format && record.output_format !== scope.output_format) return false;
+  return true;
+}
+
+function aggregate(records, confidence) {
   var byModel = {};
+  for (var i = 0; i < records.length; i++) {
+    var r = records[i];
+    if (!r.model) continue;
+    var key = r.model;
+    if (!byModel[key]) {
+      byModel[key] = {
+        model: key,
+        attempts: 0,
+        transport_successful: 0,
+        quality_attempts: 0,
+        quality_successful: 0,
+        rate_limits: 0,
+        total_cost: 0,
+        confidence: confidence,
+      };
+    }
+    byModel[key].attempts++;
+    if (r.transport_success === true || (r.transport_success == null && r.success)) {
+      byModel[key].transport_successful++;
+    }
+    if (r.failure_kind === 'rate_limit') byModel[key].rate_limits++;
+    if (r.quality_pass != null) {
+      byModel[key].quality_attempts++;
+      if (r.quality_pass) byModel[key].quality_successful++;
+    } else if (r.success != null && !r.failure_kind) {
+      // Legacy success means API availability only; retain it as low-confidence quality.
+      byModel[key].quality_attempts++;
+      if (r.success) byModel[key].quality_successful++;
+    }
+    byModel[key].total_cost += r.cost || 0;
+  }
+  return Object.keys(byModel).map(function(k) {
+    var item = byModel[k];
+    // Backward-compatible names for older callers.
+    item.successful = item.quality_successful;
+    return item;
+  });
+}
 
+function getStatsForChunkType(chunkType, opts) {
+  opts = opts || {};
+  var scope = {
+    persona: opts.persona || '',
+    effort: opts.effort || '',
+    task_type: opts.taskType || opts.task_type || chunkType || '',
+    output_format: opts.outputFormat || opts.output_format || '',
+  };
+  var lines = loadLines();
+  var parsed = [];
   for (var i = 0; i < lines.length; i++) {
     try {
       var r = JSON.parse(lines[i]);
-      if (!r.model) continue;
-      var key = r.model;
-      if (!byModel[key]) byModel[key] = { model: key, attempts: 0, successful: 0, total_cost: 0 };
-      byModel[key].attempts++;
-      if (r.success) byModel[key].successful++;
-      byModel[key].total_cost += r.cost || 0;
+      if (r.model) parsed.push(r);
     } catch (e) { /* skip corrupt line */ }
   }
-
-  return Object.keys(byModel).map(function(k) { return byModel[k]; });
+  var scoped = parsed.filter(function(r) { return matchesScope(r, scope); });
+  if (scoped.length) return aggregate(scoped, 'scoped');
+  var legacy = parsed.filter(function(r) { return !r.scope_version; });
+  return aggregate(legacy, 'legacy');
 }
 
 function getRecentFailures(limit) {
@@ -84,5 +143,6 @@ module.exports = {
   record: record,
   getStatsForChunkType: getStatsForChunkType,
   getRecentFailures: getRecentFailures,
-  TELEMETRY_FILE: TELEMETRY_FILE,
+  telemetryFile: telemetryFile,
+  TELEMETRY_FILE: DEFAULT_TELEMETRY_FILE,
 };

package/dist/lib/collect.js

@@ -25,6 +25,7 @@ const {
   writeSourceManifestNotes,
   connectDiscoveredSources,
 } = require('./source-discovery');
+const uiLibraries = require('./ui-libraries');
 
 const { resolvePackageRoot } = require('./platforms');
 const PACKAGE_ROOT = resolvePackageRoot(__dirname);
@@ -675,6 +676,7 @@ async function collect(opts = {}) {
   console.log(`   Mode:  ${modeParts.join(' + ') || 'scan'}\n`);
 
   const scan = scanAndDraft({ cwd, vaultPath, dryRun });
+  const uiLibDetection = uiLibraries.detectInstalledUiLibraries({ cwd });
 
   const sourceDiscoveries = discoverSources
     ? discoverKnowledgeSources({ cwd, config })
@@ -721,10 +723,20 @@ async function collect(opts = {}) {
       })),
       webUrls: webPlan.urls.map((u) => ({ url: u.url, source: u.source })),
       webQueries: webPlan.queries,
+      uiLibraries: uiLibraries.sessionPayload(uiLibDetection),
       sample: scan.notes.slice(0, 8).map((n) => n.vaultRel),
     }, null, 2));
     console.log('');
-    return { vaultPath, projectId, dryRun: true, ...scan, sources: sourceDiscoveries, web: webPlan, enrich: null, sync: null };
+    return { vaultPath, projectId, dryRun: true, ...scan, sources: sourceDiscoveries, web: webPlan, uiLibraries: uiLibDetection, enrich: null, sync: null };
+  }
+
+  const uiLibNote = uiLibraries.writeInstalledUiLibrariesNote({
+    vaultPath,
+    detection: uiLibDetection,
+    dryRun: false,
+  });
+  if (uiLibNote.written) {
+    console.log(`\n🧩 UI libraries: ${uiLibDetection.installed.length} detected → Tech/Installed-UI-Libraries.md`);
   }
 
   let sourceManifest = { written: [] };
@@ -806,6 +818,7 @@ async function collect(opts = {}) {
       content_sources: sources,
       vault_path: vaultPath,
       last_collect_at: new Date().toISOString(),
+      installed_ui_libraries: uiLibraries.sessionPayload(uiLibDetection),
       digest: {
         ...(state.digest || {}),
         task_map_summary: `Collected knowledge vault (${scan.notes.length} notes) from ${cwd}`,
@@ -847,6 +860,7 @@ async function collect(opts = {}) {
     },
     enrich: enrichResult,
     sync: syncResult,
+    uiLibraries: uiLibDetection,
   };
 }
 

package/dist/lib/cost.js

@@ -20,6 +20,7 @@ const fs   = require('fs');
 const path = require('path');
 const os   = require('os');
 const session = require('./session');
+const modelRegistry = require('./model-registry');
 
 const CONFIG_FILE = path.join(os.homedir(), '.analyzthis_design', 'config.json');
 
@@ -51,20 +52,27 @@ function computeRunCost(state, pricing = {}) {
 
   let total = 0;
   const byExpert = (log.length ? log : [{ persona: 'unknown', effort: m.mode || 'lite', model: null }]).map((entry) => {
-    const price = entry.model ? pricing[entry.model] : null;
+    const modelId = entry.model_id || entry.model;
+    let price = modelId ? (pricing[modelId] || pricing[entry.model]) : null;
+    if (!price && modelId && modelId.includes('/')) {
+      const split = modelId.indexOf('/');
+      price = modelRegistry.find(modelId.slice(0, split), modelId.slice(split + 1));
+    }
+    const inTok = entry.input_tokens != null ? entry.input_tokens : inPerCall;
+    const outTok = entry.output_tokens != null ? entry.output_tokens : outPerCall;
     let cost = 0;
     if (price) {
-      cost = (inPerCall / 1e6) * (price.input_per_m || 0) + (outPerCall / 1e6) * (price.output_per_m || 0);
-    } else if (entry.model) {
-      unpriced.push(entry.model);
+      cost = modelRegistry.estimateCost(price, inTok, outTok);
+    } else if (modelId) {
+      unpriced.push(modelId);
     }
     total += cost;
     return {
       persona: entry.persona,
       effort: entry.effort,
-      model: entry.model,
-      inTok: inPerCall,
-      outTok: outPerCall,
+      model: modelId,
+      inTok,
+      outTok,
       cost: Number(cost.toFixed(6)),
     };
   });

package/dist/lib/design-spec.js

@@ -98,7 +98,28 @@ function validateDesignSpec(spec) {
     }
   }
 
-  // Rank #1 component should exist with hierarchy_rank 1
+  if (spec.motion && spec.motion.enabled) {
+    for (const key of ['library', 'import_path', 'timing_ms', 'easing', 'reduced_motion']) {
+      if (!spec.motion[key] || !String(spec.motion[key]).trim()) {
+        errors.push(`motion.${key} is required when motion.enabled is true`);
+      }
+    }
+    const timing = String(spec.motion.timing_ms || '');
+    const ms = parseInt(timing, 10);
+    if (!Number.isNaN(ms) && ms > 400) {
+      errors.push('motion.timing_ms must stay at or under 400ms for product UI (cite motion.csv)');
+    }
+    const lib = String(spec.motion.library || '').toLowerCase();
+    const marketing = ['magic', 'aceternity', '21st', 'react bits', 'lottie', 'rive', 'lenis', 'spline'];
+    const notes = String(spec.motion.notes || '').toLowerCase();
+    const allowedSurface = /landing|onboard|first-run|marketing|empty/.test(notes);
+    if (marketing.some((k) => lib.indexOf(k) !== -1) && !allowedSurface) {
+      errors.push('motion.library looks like marketing FX — set notes to landing/onboarding/first-run or pick a product library (Motion, Auto-Animate, CSS)');
+    }
+    if (Array.isArray(spec.motion.moments) && spec.motion.moments.length > 1) {
+      errors.push('motion.moments may contain at most one peak (Zara rule)');
+    }
+  }
   if (Array.isArray(spec.components) && Array.isArray(spec.information_hierarchy) && spec.information_hierarchy.length) {
     const hasRank1 = spec.components.some((c) => c.hierarchy_rank === 1);
     if (!hasRank1) {
@@ -208,7 +229,16 @@ function templateMarkdown() {
     "error": "Inline alert + retry",
     "success": "Toast + updated primary data"
   },
-  "motion": { "enabled": false, "notes": "" },
+  "motion": {
+    "enabled": false,
+    "library": "",
+    "import_path": "",
+    "timing_ms": "150-250",
+    "easing": "ease-out",
+    "reduced_motion": "opacity only or none",
+    "moments": [],
+    "notes": ""
+  },
   "do": ["Single primary CTA above the fold", "Use existing shadcn components only"],
   "dont": ["Invent hex colors", "Add second primary button"],
   "wireframe_ref": "synthesized",