analyzthis_design 2.5.1 → 2.6.0

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/install.js

@@ -59,6 +59,7 @@ const SKILLS = [
   'evolve-check',
   'devi',
   'design-director',
+  'mood-board',
   'design-spec',
   'design-personas',
   'design-reference',

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,56 @@ 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: 'Visual mood board. Zara crops 20-24 real UI elements (cards, tables, type, colour, nav) from 6+ live sites into a sectioned collage with real colours and fonts. Arjun/Noor/Priya/Meera vote as advice. The board opens in the browser and the USER clicks keep / maybe / reject — the user\'s choice overrides every persona, and the locked direction is saved for all personas. kind=mood keeps the older link-and-tag board.',
     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: ['ui', 'mood'], description: 'ui = visual element board (default). mood = older tagged-URL board.' },
+        action: { type: 'string', enum: ['create', 'brief', 'capture_script', 'tiles', 'film', 'jury', 'votes', 'show', 'decide', 'rescout', 'lock', 'status', 'frames', 'verdict'], description: 'create (default) → brief → tiles (Zara crops) and film (records urls scrolling as motion tiles; needs playwright-core + Chrome) → jury → votes (advice) → show (user decides in browser) → rescout or lock. decide records a user choice from chat. frames/verdict are older names for tiles/votes.' },
+        board: { type: 'string', description: 'Board id' },
+        adjectives: { type: 'array', items: { type: 'string' }, description: 'Three feel words for the brief' },
+        not_this: { type: 'string', description: 'One thing this board must not look like' },
+        sections: { type: 'array', items: { type: 'string', enum: ['first_screen', 'typography', 'color', 'components', 'imagery', 'motion'] }, description: 'Sections this board needs' },
+        confirmed_by_user: { type: 'boolean', description: 'User approved the brief (action=brief)' },
+        selector: { type: 'string', description: 'CSS selector for action=capture_script' },
+        text: { type: 'string', description: 'Visible text that narrows the selector match (action=capture_script)' },
+        tiles: {
+          type: 'array',
+          description: 'Element crops (action=tiles)',
+          items: {
+            type: 'object',
+            properties: {
+              page_url: { type: 'string', description: 'Exact page the element came from (required)' },
+              image_path: { type: 'string', description: 'Local image file, or the saved Page.captureScreenshot JSON file' },
+              image_base64: { type: 'string', description: 'Inline Page.captureScreenshot data when no file was written' },
+              image_url: { type: 'string', description: 'Remote image URL if no local crop' },
+              video_path: { type: 'string', description: 'Local WebM/MP4 scroll film (motion tiles)' },
+              stills: { type: 'array', items: { type: 'string' }, description: 'Up to 4 waypoint still image paths for a film' },
+              section: { type: 'string', enum: ['first_screen', 'typography', 'color', 'components', 'imagery', 'motion'] },
+              element: { type: 'string', description: 'What the element is, e.g. "pricing card"' },
+              tokens: { type: 'object', description: 'From capture_script: colors, fonts, radius, spacing, font_size' },
+              steal: { type: 'string' }, refuse: { type: 'string' }, peak: { type: 'string' },
+              concept: { type: 'boolean', description: 'True if this is a concept shot, not shipped product' },
+            },
+          },
+        },
+        votes: {
+          type: 'array',
+          description: 'Persona advice (action=votes): [{tile, persona, vote: keep|skip, because}]',
+          items: { type: 'object' },
+        },
+        verdict: { type: 'string', enum: ['SHIP', 'REVISE', 'BLOCK'], description: 'Team advice verdict (action=votes)' },
+        summary: { type: 'string', description: 'Team because-lines (action=votes)' },
+        tile: { type: 'string', description: 'Tile number or id (action=decide)' },
+        decision: { type: 'string', enum: ['keep', 'maybe', 'reject', 'clear'], description: 'User decision (action=decide)' },
+        note: { type: 'string', description: 'User note (decide, rescout, lock)' },
+        urls: { type: 'array', items: { type: 'string' }, description: 'Reference URLs (kind=mood), or pages to film (action=film)' },
+        element: { type: 'string', description: 'Tile name (action=film), default "Scroll film — <site>"' },
+        section: { type: 'string', enum: ['first_screen', 'typography', 'color', 'components', 'imagery', 'motion'], description: 'Section for action=film (default motion)' },
+        steal: { type: 'string' }, refuse: { type: 'string' }, peak: { type: 'string' },
+        auto: { type: 'boolean', description: 'Auto-collect references (kind=mood only)' },
       },
-      required: ['task'],
     },
   },
   {
@@ -466,7 +507,145 @@ function handleCombinationPass(skillId, args) {
   return { prompt: prompt, skill: skillId, task: task, persona: skillId, verdicts: 1 };
 }
 
+// One live board server per board id, kept for the life of the MCP process.
+var moodBoardServers = {};
+
+function tileCountLine(board) {
+  var sites = {};
+  board.tiles.forEach(function(t) { if (t.site) sites[t.site] = true; });
+  return board.tiles.length + ' tile(s) from ' + Object.keys(sites).length + ' site(s)';
+}
+
 function handleMoodBoard(args) {
+  var task = args.task || '';
+  var kind = args.kind === 'mood' ? 'mood' : 'ui';
+  var action = args.action || 'create';
+  var mb = require('./moodboard');
+  var view = require('./moodboard-view');
+  var ref = { boardId: args.board };
+  var zaraNext = function(board) {
+    return 'You are Zara on a Scout Pass. Open real pages in the browser. Do not invent URLs.\n\n' + board.scout.brief +
+      '\n\nBoard id: ' + board.board_id +
+      '\nToken script for Runtime.evaluate: call analyzthis_mood_board action=capture_script selector=<css>.' +
+      '\nSave tiles with action=tiles, board=' + board.board_id + ', tiles=[{page_url,image_path,section,element,tokens,steal,refuse,peak}].' +
+      '\nThen action=jury for advice, then action=show and open the URL so the user decides.';
+  };
+
+  try {
+    if (action === 'capture_script') {
+      return { result: mb.captureScript(args.selector || 'body', args.text || '') };
+    }
+
+    if (action === 'brief') {
+      var briefed = mb.setBrief({
+        boardId: args.board, adjectives: args.adjectives, not_this: args.not_this,
+        sections: args.sections, confirmed_by_user: args.confirmed_by_user,
+      });
+      return { result: 'Brief saved.', board_id: briefed.board.board_id, brief: briefed.board.brief };
+    }
+
+    if (action === 'tiles' || action === 'frames') {
+      var tiles = args.tiles || args.frames || [{
+        page_url: args.page_url || args.url, element: args.element || args.title, section: args.section,
+        image_path: args.image_path, image_url: args.image_url, tokens: args.tokens,
+        video_path: args.video_path, stills: args.stills, steal: args.steal, refuse: args.refuse, peak: args.peak,
+      }];
+      var added = mb.addTiles({ boardId: args.board, tiles: tiles });
+      return {
+        result: 'Saved ' + added.added.length + ' tile(s). Board now has ' + tileCountLine(added.board) +
+          '. Target ' + mb.TILE_TARGET.min + '-' + mb.TILE_TARGET.max + ' from ' + mb.TILE_TARGET.sites + '+ sites.' +
+          (added.skipped.length ? ' Skipped: ' + JSON.stringify(added.skipped) : ''),
+        board_id: added.board.board_id,
+        skipped: added.skipped,
+      };
+    }
+
+    if (action === 'jury') {
+      var juryBoard = mb.loadUiBoard(ref);
+      if (!juryBoard.tiles.length) return { error: 'NEED_SCOUT: Zara has not added tiles yet.' };
+      return { prompt: mb.juryPrompt(juryBoard, ''), board_id: juryBoard.board_id };
+    }
+
+    if (action === 'votes' || action === 'verdict') {
+      var voted = mb.recordPersonaVotes({
+        boardId: args.board, votes: args.votes || [], verdict: args.verdict, summary: args.summary,
+      });
+      return {
+        result: 'Team advice saved' + (voted.ignored.length ? ' (ignored: ' + JSON.stringify(voted.ignored) + ')' : '') +
+          '. The user decides next: call action=show and open the URL in the browser.',
+        board_id: voted.board.board_id,
+        scout: voted.board.scout,
+      };
+    }
+
+    if (action === 'film') {
+      return require('./moodboard-film').filmTiles({
+        boardId: args.board, urls: args.urls || (args.page_url ? [args.page_url] : []),
+        section: args.section, element: args.element, steal: args.steal, refuse: args.refuse, peak: args.peak,
+      }).then(function(out) {
+        var added = out.saved ? out.saved.added : [];
+        return {
+          result: 'Filmed ' + added.length + ' site(s) as motion tiles' + (out.saved ? '. Board now has ' + tileCountLine(out.saved.board) : '') + '.' +
+            (out.failed.length ? ' Failed: ' + JSON.stringify(out.failed) : '') +
+            (out.saved && out.saved.skipped.length ? ' Skipped: ' + JSON.stringify(out.saved.skipped) : ''),
+          board_id: args.board,
+        };
+      }).catch(function(e) { return { error: e.message }; });
+    }
+
+    if (action === 'show') {
+      var existing = moodBoardServers[args.board];
+      if (existing) return { result: 'Board is live at ' + existing.url + ' — open it with browser_navigate.', url: existing.url };
+      return view.serveBoard({ boardId: args.board }).then(function(live) {
+        moodBoardServers[args.board] = live;
+        return {
+          result: 'Board is live at ' + live.url + ' — open it with browser_navigate. The user clicks keep / maybe / reject; their choice overrides every persona.',
+          url: live.url,
+        };
+      }).catch(function(e) { return { error: e.message }; });
+    }
+
+    if (action === 'decide') {
+      var decided = mb.recordUserDecision({ boardId: args.board, tile: args.tile, decision: args.decision, note: args.note });
+      return { result: 'User decision saved on tile ' + args.tile + '. It outranks every persona vote.', board_id: decided.board.board_id };
+    }
+
+    if (action === 'rescout') {
+      var again = mb.requestRescout({ boardId: args.board, note: args.note });
+      return { prompt: zaraNext(again.board), board_id: again.board.board_id, scout: again.board.scout };
+    }
+
+    if (action === 'lock') {
+      var locked = mb.lockDirection({ boardId: args.board, note: args.note });
+      return { result: 'Direction locked by the user and saved to the session as design_direction. Every persona must follow it.', direction: locked.board.direction };
+    }
+
+    if (action === 'status') {
+      var b = mb.loadUiBoard(ref);
+      return { result: JSON.stringify({ board_id: b.board_id, scout: b.scout, brief: b.brief, tiles: tileCountLine(b), direction: mb.computeDirection(b) }, null, 2) };
+    }
+  } catch (e) {
+    return { error: e.message };
+  }
+
+  if (kind === 'ui') {
+    if (!task) return { error: 'task is required to open a mood board' };
+    return mb.buildMoodBoard({
+      task: task, kind: 'ui', discover: false,
+      brief: { adjectives: args.adjectives, not_this: args.not_this, sections: args.sections },
+    }).then(function(created) {
+      return {
+        prompt: 'First show the user this brief (job, 3 adjectives, one "not this", sections) and let them correct it with action=brief confirmed_by_user=true.\n\n' + zaraNext(created.board),
+        board_id: created.board.board_id,
+        brief: created.board.brief,
+      };
+    }).catch(function(e) { return { error: e.message }; });
+  }
+
+  return handleLinkMoodBoard(args);
+}
+
+function handleLinkMoodBoard(args) {
   var skill = readSkill('mood-board');
   var task = args.task || '';
   var urls = (args.urls || []).join('\n');
@@ -857,8 +1036,8 @@ function startStdioServer(catalog) {
     if (method === 'tools/call') {
       var toolName = params.name;
       var toolArgs = params.arguments || {};
-      var result = handleToolCall(toolName, toolArgs);
-
+      // Some tools (mood board create / show) are async.
+      Promise.resolve().then(function() { return handleToolCall(toolName, toolArgs); }).then(function(result) {
       if (result.error) {
         send({
           jsonrpc: '2.0',
@@ -881,6 +1060,9 @@ function startStdioServer(catalog) {
           },
         });
       }
+      }).catch(function(e) {
+        send({ jsonrpc: '2.0', id: id, error: { code: -32603, message: e.message } });
+      });
       return;
     }
 

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,
+};