analyzthis_design 2.5.1 → 2.5.2

package/dist/lib/moodboard.js

@@ -66,11 +66,43 @@ function writeJson(filePath, obj) {
   fs.writeFileSync(filePath, JSON.stringify(obj, null, 2));
 }
 
+function persistBoard(board, workspaceDir) {
+  var projectId = board.project_id;
+  var bDir = boardDir(projectId, board.board_id);
+  board.updated_at = new Date().toISOString();
+  writeJson(path.join(bDir, 'board.json'), board);
+  var ws = workspaceDir || defaultWorkspaceDir();
+  ensureDir(ws);
+  var workspacePath = path.join(ws, board.board_id + '.json');
+  try { fs.writeFileSync(workspacePath, JSON.stringify(board, null, 2)); }
+  catch (e) { /* best effort */ }
+  return { board: board, boardDir: bDir, workspacePath: workspacePath };
+}
+
+function defaultScoutBrief(task, round, vetoNotes) {
+  var lines = [
+    'Zara Scout Pass, round ' + (round || 1) + '.',
+    'Job: ' + String(task).slice(0, 240),
+    'Find 3-5 UI frames. Search Google Images, Dribbble, or Pinterest (or live product pages). Open them. Do not invent URLs. Do not generate AI comps.',
+    'Lens: Peak-End, first 2 seconds. Same job? Peak feeling? One steal, one refuse. Concept shots allowed if you say they are concept. Never sell a Dribbble hero as shipped product.',
+    'Skip generic AI-purple heroes and cinematic GSAP landings unless this job is a marketing page.',
+    'For each frame write: steal (one thing), refuse (one thing), peak (one first impression).',
+    'Then stop. The jury (Arjun, Noor, Priya, Meera) votes. You do not score your own picks.',
+  ];
+  if (vetoNotes) {
+    lines.push('Last jury sent you back. Constraints: ' + String(vetoNotes).slice(0, 500));
+  }
+  return lines.join('\n');
+}
+
 // ─── Source discovery for mood references ───────────────────────────────────
 
 // Known hosts that expose an image or a design article we can fetch as text.
 var MOOD_REFERENCE_HOSTS = [
   'dribbble.com',
+  'pinterest.com',
+  'www.pinterest.com',
+  'pin.it',
   'mobbin.com',
   'behance.net',
   'www.behance.net',
@@ -362,7 +394,8 @@ async function buildMoodBoard(opts) {
 
   var refs = [];
   var userRefs = opts.userReferences || [];
-  var discover = opts.discover !== false;
+  var kind = opts.kind === 'ui' ? 'ui' : 'mood';
+  var discover = kind === 'ui' ? !!(opts.urls && opts.urls.length) : opts.discover !== false;
 
   if (discover) {
     var plan = discoverReferenceUrls({ task: task, urls: opts.urls || [], config: config });
@@ -397,28 +430,27 @@ async function buildMoodBoard(opts) {
   var board = {
     board_id: boardId,
     project_id: projectId,
+    kind: kind,
     task: task,
     created_at: new Date().toISOString(),
     updated_at: new Date().toISOString(),
     references: refs,
+    frames: [],
     design_system_pack: dsPack,
     deliberation: null,
     synthesis: null,
     user_contributions: userRefs.length,
+    scout: kind === 'ui' ? {
+      persona: 'zara',
+      round: 1,
+      max_rounds: 3,
+      status: 'awaiting_scout',
+      brief: defaultScoutBrief(task, 1, ''),
+      last_veto: '',
+    } : null,
   };
 
-  writeJson(path.join(bDir, 'board.json'), board);
-
-  // Copy/symlink to workspace so the user can open it directly.
-  ensureDir(workspaceDir);
-  var workspacePath = path.join(workspaceDir, boardId + '.json');
-  try {
-    fs.writeFileSync(workspacePath, JSON.stringify(board, null, 2));
-  } catch (e) {
-    // workspace write is best-effort (e.g. read-only cwd)
-  }
-
-  return { board: board, boardDir: bDir, workspacePath: workspacePath };
+  return persistBoard(board, workspaceDir);
 }
 
 function detectStack(vaultPath) {
@@ -443,17 +475,39 @@ async function critiqueMoodBoard(opts) {
   var board = loadJson(boardPath);
   if (!board) throw new Error('Board not found: ' + boardId);
 
-  var experts = opts.experts || ['arjun', 'meera', 'priya', 'zara', 'noor'];
+  var isUi = board.kind === 'ui';
+  var experts = opts.experts || (isUi ? ['arjun', 'meera', 'priya', 'noor'] : ['arjun', 'meera', 'priya', 'zara', 'noor']);
   var task = opts.task || board.task;
 
-  // Build a synthetic critique task that includes the board and DS pack.
-  var refsSummary = board.references.map(function(r, idx) {
-    return '[' + (idx + 1) + '] ' + r.title + ' (' + r.type + ') tags=' + r.tags.join(',') + ' — ' + (r.url || r.description).slice(0, 120);
-  }).join('\n');
+  if (isUi && (!board.frames || !board.frames.length)) {
+    var need = new Error('Zara has not scouted yet. Add 3-5 frames, then critique.');
+    need.code = 'NEED_SCOUT';
+    throw need;
+  }
+
+  var refsSummary = isUi
+    ? board.frames.map(function(f, idx) {
+        return '[' + (idx + 1) + '] ' + f.title + ' round=' + (f.round || 1) +
+          ' steal=' + (f.steal || '') + ' refuse=' + (f.refuse || '') +
+          ' peak=' + (f.peak || '') + ' — ' + (f.url || '').slice(0, 120);
+      }).join('\n')
+    : board.references.map(function(r, idx) {
+        return '[' + (idx + 1) + '] ' + r.title + ' (' + r.type + ') tags=' + (r.tags || []).join(',') + ' — ' + (r.url || r.description || '').slice(0, 120);
+      }).join('\n');
 
   var dsText = formatDsPack(board.design_system_pack);
 
-  var critiqueTask = [
+  var critiqueTask = isUi ? [
+    'UI image-board jury for: ' + task,
+    'Zara scouted these frames. She does not vote. KEEP or SKIP each frame with one because-sentence.',
+    'Do not reward cinematic marketing motion on a daily working surface.',
+    '',
+    'Frames:\n' + refsSummary,
+    '',
+    dsText,
+    '',
+    'Use the Honeycomb rigor matrix. Rank the best 2-3 frames. Verdict SHIP only if the set fits the job. REVISE or BLOCK sends Zara to scout again.'
+  ].join('\n') : [
     'Mood-board critique for: ' + task,
     '',
     'References:\n' + refsSummary,
@@ -463,7 +517,6 @@ async function critiqueMoodBoard(opts) {
     'Each persona must use the Honeycomb rigor matrix to evaluate which references are appropriate for the user and why. Output scores, top concerns, and a ranked shortlist of the best 2-3 references. Then participate in adversarial deliberation until consensus.'
   ].join('\n');
 
-  // Use the orchestrator directly, but force the experts to the mood-board set.
   var result = await orchestratorRun({
     task: critiqueTask,
     experts: experts,
@@ -479,17 +532,94 @@ async function critiqueMoodBoard(opts) {
 
   board.deliberation = result.deliberation;
   board.synthesis = result.synthesis;
-  board.updated_at = new Date().toISOString();
   board.critique_task = critiqueTask;
+  if (isUi) applyJuryOutcome(board, result.synthesis);
 
-  writeJson(boardPath, board);
-  var workspaceDir = opts.workspaceDir || defaultWorkspaceDir();
-  ensureDir(workspaceDir);
-  var workspacePath = path.join(workspaceDir, boardId + '.json');
-  try { fs.writeFileSync(workspacePath, JSON.stringify(board, null, 2)); }
-  catch (e) { /* best effort */ }
+  var saved = persistBoard(board, opts.workspaceDir || defaultWorkspaceDir());
+  return { board: saved.board, boardDir: saved.boardDir, workspacePath: saved.workspacePath, orchestratorResult: result };
+}
+
+function applyJuryOutcome(board, synthesis) {
+  var verdict = String((synthesis && synthesis.verdict) || '').toUpperCase();
+  var scout = board.scout || {};
+  var maxRounds = scout.max_rounds || 3;
+  var notes = '';
+  if (synthesis && synthesis.summary) notes = synthesis.summary;
+  else if (synthesis && synthesis.top3 && synthesis.top3.join) notes = synthesis.top3.join('; ');
+  else notes = verdict;
+
+  if (verdict === 'SHIP') {
+    scout.status = 'done';
+    scout.last_veto = '';
+  } else if ((scout.round || 1) >= maxRounds) {
+    scout.status = 'raj';
+    scout.last_veto = String(notes).slice(0, 600);
+    scout.brief = 'Max scout rounds reached. Raj or the designer picks from the frames on this board.\n' + scout.last_veto;
+  } else {
+    scout.round = (scout.round || 1) + 1;
+    scout.status = 'awaiting_scout';
+    scout.last_veto = String(notes).slice(0, 600);
+    scout.brief = defaultScoutBrief(board.task, scout.round, scout.last_veto);
+  }
+  board.scout = scout;
+}
 
-  return { board: board, orchestratorResult: result };
+function addFrames(opts) {
+  opts = opts || {};
+  var projectId = opts.project || session.getProjectId();
+  var boardId = opts.boardId;
+  var incoming = opts.frames || (opts.frame ? [opts.frame] : []);
+  if (!boardId || !incoming.length) throw new Error('--board and at least one frame are required');
+
+  var bDir = boardDir(projectId, boardId);
+  var board = loadJson(path.join(bDir, 'board.json'));
+  if (!board) throw new Error('Board not found: ' + boardId);
+  if (board.kind !== 'ui') throw new Error('Frames belong on a --kind ui board.');
+
+  board.frames = board.frames || [];
+  var round = (board.scout && board.scout.round) || 1;
+  for (var i = 0; i < incoming.length; i++) {
+    var f = incoming[i] || {};
+    if (!f.url) continue;
+    board.frames.push({
+      id: generateBoardId(),
+      url: f.url,
+      title: f.title || 'Frame',
+      steal: f.steal || '',
+      refuse: f.refuse || '',
+      peak: f.peak || '',
+      surface: f.surface || '',
+      source: 'zara_scout',
+      round: round,
+      added_at: new Date().toISOString(),
+    });
+  }
+  if (board.scout) board.scout.status = 'awaiting_jury';
+  return persistBoard(board, opts.workspaceDir);
+}
+
+function getBoard(opts) {
+  opts = opts || {};
+  var projectId = opts.project || session.getProjectId();
+  var boardId = opts.boardId;
+  if (!boardId) throw new Error('board is required');
+  var board = loadJson(path.join(boardDir(projectId, boardId), 'board.json'));
+  if (!board) throw new Error('Board not found: ' + boardId);
+  return board;
+}
+
+function recordJuryVerdict(opts) {
+  opts = opts || {};
+  var board = getBoard(opts);
+  if (board.kind !== 'ui') throw new Error('Jury verdict belongs on a ui board.');
+  var synthesis = {
+    verdict: String(opts.verdict || '').toUpperCase(),
+    summary: opts.summary || '',
+    top3: opts.top3 || [],
+  };
+  applyJuryOutcome(board, synthesis);
+  board.synthesis = synthesis;
+  return persistBoard(board, opts.workspaceDir);
 }
 
 // ─── Add user reference and rerun ─────────────────────────────────────────────
@@ -556,6 +686,10 @@ module.exports = {
   buildMoodBoard: buildMoodBoard,
   critiqueMoodBoard: critiqueMoodBoard,
   addUserReferenceAndRerun: addUserReferenceAndRerun,
+  addFrames: addFrames,
+  getBoard: getBoard,
+  recordJuryVerdict: recordJuryVerdict,
+  defaultScoutBrief: defaultScoutBrief,
   listBoards: listBoards,
   boardDir: boardDir,
   formatDsPack: formatDsPack,

package/dist/lib/orchestrator/run.js

@@ -30,6 +30,7 @@ const fs   = require('fs');
 const path = require('path');
 const os   = require('os');
 const https = require('https');
+const crypto = require('crypto');
 const session  = require('../session');
 const retrieve = require('../retrieve');
 const cache    = require('../cache');
@@ -40,7 +41,10 @@ const ranker = require('../ranker');
 const knowledge = require('../knowledge');
 const chunkRun = require('../chunk-run');
 const chunkModels = require('../chunk-models');
+const modelPolicy = require('../model-policy');
+const modelRegistry = require('../model-registry');
 const referencePack = require('../reference-pack');
+const outputQuality = require('../output-quality');
 const { callHostLlm, createRun, HostLlmPendingError, printDeviInstructions, findLatestRun, loadManifest: loadHostManifest } = require('../host-llm');
 const { resolveDefaultProvider, resolveTierProvider } = require('../provider');
 const synthesis = require('../synthesis');
@@ -229,7 +233,7 @@ function classifyEffort({ routing, digest, manifest, scopedMode, fullChain, isDe
  *   3. chain.tiers[manifest.tier]         (legacy fallback, v1.9)
  *   4. manifest.max_output_tokens         (last resort for the cap)
  */
-function resolveModel({ manifest, effort, chain, config, defaultProvider, defaultModel, gateName }) {
+function resolveModel({ manifest, effort, chain, config, defaultProvider, defaultModel, gateName, explicitProvider, explicitModel }) {
   let effKey = effort;
   const gateOverride = chain.gate_override;
   if (gateName && gateOverride && (gateOverride.applies_to || []).includes(gateName)) {
@@ -240,12 +244,35 @@ function resolveModel({ manifest, effort, chain, config, defaultProvider, defaul
   const matrix   = (chain.effort_matrix && chain.effort_matrix[effKey]) || {};
   const legacy   = (config.orchestrator?.tiers && config.orchestrator?.tiers[manifest.tier]) || {};
 
-  const provider = override.provider || matrix.provider || legacy.provider || defaultProvider;
-  const model    = override.model    || matrix.model    || legacy.model    || defaultModel;
+  let provider = override.provider || matrix.provider || legacy.provider || defaultProvider;
+  let model    = override.model    || matrix.model    || legacy.model    || defaultModel;
+  let requestedModel = explicitModel;
+  if (explicitProvider && !requestedModel) {
+    if (config.orchestrator?.provider === explicitProvider && config.orchestrator?.model) {
+      requestedModel = config.orchestrator.model;
+    } else if (explicitProvider === 'ollama') {
+      requestedModel = config.ollama?.model || 'qwen2.5';
+    } else {
+      const known = modelRegistry.MODELS.find((item) =>
+        item.provider === explicitProvider && (!item.effort || item.effort.includes(effKey)));
+      requestedModel = known?.model;
+    }
+  }
+  const policy = modelPolicy.resolveAssignment({
+    persona: manifest.id,
+    effort: effKey,
+    config,
+    explicitProvider,
+    explicitModel: requestedModel,
+  });
+  if (policy) {
+    provider = policy.spec.provider;
+    model = policy.spec.model;
+  }
   const resolvedProvider = resolveTierProvider(provider, defaultProvider);
   const maxTokens = override.max_output_tokens || matrix.max_output_tokens
     || config.orchestrator?.max_tokens?.[manifest.tier] || manifest.max_output_tokens;
-  return { provider: resolvedProvider, model, maxTokens, effort: effKey };
+  return { provider: resolvedProvider, model, maxTokens, effort: effKey, policy: policy && policy.source };
 }
 
 function ollamaJson(baseUrl, model, system, user, maxTokens) {
@@ -500,6 +527,7 @@ async function runUnchunked(opts = {}) {
     state = session.show({ project: init.projectId });
   }
   const projectId = state.project_id;
+  const runId = 'run-' + Date.now() + '-' + crypto.randomBytes(4).toString('hex');
 
   // Host LLM run directory (Devi bridge — no API keys)
   let hostContext = null;
@@ -554,6 +582,8 @@ async function runUnchunked(opts = {}) {
   session.update({
     project: projectId,
     patch: {
+      active_run: { id: runId, mode: 'unchunked', at: new Date().toISOString() },
+      persona_outputs: {},
       routing_decision: routing,
       figma_node: figma ? { url: figma, confirmed: false } : state.figma_node,
       mode: 'assess_only',
@@ -603,8 +633,13 @@ async function runUnchunked(opts = {}) {
   let cacheHits = 0;
   let costUsd = 0;
 
-  async function loadPersonaContext(personaId, { isProduceRound, isObjectionRound }) {
+  async function loadPersonaContext(personaId, { isProduceRound, isObjectionRound, gateName = null }) {
     const manifest = loadManifest(personaId);
+    const effectiveGateName = gateName || (
+      personaId === 'arjun' && dsAtRisk.length
+        ? 'ds_gate'
+        : null
+    );
     const useDeepWireframe = ideation_chain && wireframePersonas.has(personaId);
     const isReviewRound = isObjectionRound && !isProduceRound;
 
@@ -645,7 +680,9 @@ async function runUnchunked(opts = {}) {
     });
     const resolved = resolveModel({
       manifest, effort: isObjectionRound ? 'trivial' : effort, chain, config,
-      defaultProvider: provider, defaultModel: model, gateName: null,
+      defaultProvider: provider, defaultModel: model, gateName: effectiveGateName,
+      explicitProvider: opts.provider && opts.provider !== 'auto' ? opts.provider : (opts.model ? provider : null),
+      explicitModel: opts.model || null,
     });
 
     let finalSystem = system;
@@ -701,7 +738,12 @@ async function runUnchunked(opts = {}) {
     });
     const inTok = Math.ceil((system.length + user.length) / 4);
     const outTok = Math.ceil(text.length / 4);
-    const price = config.pricing && config.pricing[callOpts.model];
+    const actualModel = callOpts.provider === 'host' ? 'unknown' : callOpts.model;
+    const quality = outputQuality.validateOutput(text, {
+      persona: personaId,
+      outputFormat: 'persona_lite',
+    });
+    const price = callOpts.provider !== 'host' && config.pricing && config.pricing[callOpts.model];
     if (price) {
       costUsd += (inTok / 1e6) * (price.input_per_m || 0) + (outTok / 1e6) * (price.output_per_m || 0);
     }
@@ -712,10 +754,27 @@ async function runUnchunked(opts = {}) {
       output_tokens_est: outTok,
       structured_output: parseStructuredOutput(text, personaId),
       full_prompt: { system, user },
+      at: new Date().toISOString(),
+      run_id: runId,
+      attribution: {
+        provider: callOpts.provider,
+        model: actualModel,
+        model_id: callOpts.provider + '/' + actualModel,
+        effort: callOpts.effort || 'standard',
+        policy_version: modelPolicy.VERSION,
+        prompt_hash: modelPolicy.promptHash(personaId),
+        validator_version: outputQuality.VERSION,
+      },
+      quality: quality,
       effort_log_entry: {
         persona: personaId,
         effort: callOpts.effort || 'standard',
-        model: callOpts.model,
+        provider: callOpts.provider,
+        model: actualModel,
+        model_id: callOpts.provider + '/' + actualModel,
+        input_tokens: inTok,
+        output_tokens: outTok,
+        run_id: runId,
         scoped_mode: null,
       },
     };

package/dist/lib/outcome.js

@@ -118,7 +118,9 @@ function inferAllOutcomes(opts) {
           value: result.inferred,
           confidence: result.confidence,
           reason: result.reason,
-          at: new Date().toISOString()
+          at: new Date().toISOString(),
+          run_id: entry.run_id || null,
+          attribution: entry.attribution || null
         };
         session.update({ project: pid, patch: { outcome: outcomePatch } });
         inferred++;
@@ -143,6 +145,7 @@ function confirmOutcome(opts) {
 
   var state = session.show({ project: project });
   if (!state) throw new Error('No session found');
+  var output = state.persona_outputs && state.persona_outputs[persona];
 
   var outcomePatch = {
     inferred: { ...(state.outcome && state.outcome.inferred ? state.outcome.inferred : {}) },
@@ -150,7 +153,9 @@ function confirmOutcome(opts) {
   };
   outcomePatch.confirmed[persona] = {
     value: outcome,
-    at: new Date().toISOString()
+    at: new Date().toISOString(),
+    run_id: output && output.run_id || null,
+    attribution: output && output.attribution || null
   };
   delete outcomePatch.inferred[persona];
 

package/dist/lib/output-quality.js

@@ -0,0 +1,95 @@
+'use strict';
+
+/**
+ * Format-aware output validation shared by normal runs and calibration.
+ * Hard failures may trigger a bounded retry; warnings only affect quality score.
+ */
+
+var VERSION = 1;
+
+var PERSONA_FORBIDDEN = {
+  arjun: [/delight pass/i, /ARR impact/i],
+  meera: [/color contrast/i, /typography scale/i, /WCAG/i],
+  priya: [/delight moment/i, /north-star metric/i],
+  zara: [/--color-primary/i, /contrast ratio/i, /fix the token/i],
+};
+
+function issue(code, message, hard) {
+  return { code: code, message: message, hard: !!hard };
+}
+
+function validateOutput(text, opts) {
+  opts = opts || {};
+  text = typeof text === 'string' ? text.trim() : '';
+  var format = String(opts.outputFormat || opts.format || 'generic').toLowerCase();
+  var persona = String(opts.persona || '').toLowerCase();
+  var issues = [];
+
+  if (!text) issues.push(issue('empty', 'The model returned no text.', true));
+  if (text && text.length < 40) issues.push(issue('too_short', 'The answer is too short to evaluate.', true));
+
+  if (format === 'persona_lite' || format === 'lite') {
+    if (!/##\s*[A-Za-z]+(?:\s*[—-]\s*Lite)?/i.test(text)) {
+      issues.push(issue('missing_header', 'Missing persona output header.', false));
+    }
+    if (!/Top\s*2|fix|verdict|no delight needed/i.test(text)) {
+      issues.push(issue('missing_action', 'Missing an actionable finding or verdict.', true));
+    }
+  } else if (format === 'ux_audit') {
+    if (!/usab|access|hierarch|visual|UX/i.test(text)) {
+      issues.push(issue('missing_audit', 'UX audit has no UX or visual assessment.', true));
+    }
+    if (!/fix|recommend|change|keep|revise|ship|block/i.test(text)) {
+      issues.push(issue('missing_action', 'UX audit has no actionable conclusion.', true));
+    }
+  } else if (format === 'premise_assessment' || format === 'premise_check') {
+    if (!/premise|problem|assumption|framing|right problem/i.test(text)) {
+      issues.push(issue('missing_premise', 'Premise assessment does not examine the framing.', true));
+    }
+    if (!/proceed|change|reject|accept|revise|evidence/i.test(text)) {
+      issues.push(issue('missing_decision', 'Premise assessment has no decision or evidence request.', true));
+    }
+  } else if (format === 'synthesis') {
+    if (!/\b(SHIP|REVISE|BLOCK)\b/i.test(text)) {
+      issues.push(issue('missing_verdict', 'Synthesis has no SHIP, REVISE, or BLOCK verdict.', true));
+    }
+    if (!/top\s*3|action|next step|fix/i.test(text)) {
+      issues.push(issue('missing_actions', 'Synthesis has no next actions.', false));
+    }
+  }
+
+  var forbidden = PERSONA_FORBIDDEN[persona] || [];
+  for (var i = 0; i < forbidden.length; i++) {
+    if (forbidden[i].test(text)) {
+      issues.push(issue('forbidden_scope', 'The persona crossed into a forbidden scope.', true));
+    }
+  }
+
+  var hardFailures = issues.filter(function(item) { return item.hard; });
+  var warnings = issues.filter(function(item) { return !item.hard; });
+  var score = Math.max(0, 1 - hardFailures.length * 0.35 - warnings.length * 0.1);
+  return {
+    version: VERSION,
+    format: format,
+    pass: hardFailures.length === 0,
+    score: Number(score.toFixed(2)),
+    issues: issues,
+    hard_failures: hardFailures.length,
+    warnings: warnings.length,
+  };
+}
+
+function classifyError(error) {
+  var message = String(error && error.message ? error.message : error || '');
+  if (/429|rate.?limit|too many requests|quota/i.test(message)) return 'rate_limit';
+  if (/timeout|timed out|ECONNRESET|ENOTFOUND|network|socket/i.test(message)) return 'transport';
+  if (/401|403|unauthori|forbidden|api.?key/i.test(message)) return 'auth';
+  return 'provider';
+}
+
+module.exports = {
+  VERSION: VERSION,
+  PERSONA_FORBIDDEN: PERSONA_FORBIDDEN,
+  validateOutput: validateOutput,
+  classifyError: classifyError,
+};

package/dist/lib/reference-pack.js

@@ -37,6 +37,7 @@ var REFERENCE_MAP = {
     { file: 'ux-guidelines.csv', column: 'Category', limit: 3 },
     { file: 'ui-reasoning.csv', column: 'UI Category', limit: 3 },
     { file: 'charts.csv', column: 'Data Type', limit: 3 },
+    { file: 'ui-libraries.csv', column: 'Best For Tags', limit: 3 },
   ],
   zara: [
     { file: 'colors.csv', column: 'Product Type', limit: 3 },
@@ -44,6 +45,8 @@ var REFERENCE_MAP = {
     { file: 'styles.csv', column: 'Best For Tags', limit: 3 },
     { file: 'landing.csv', column: 'Keywords', limit: 3 },
     { file: 'icons.csv', column: 'Keywords', limit: 3 },
+    { file: 'motion.csv', column: 'Category', limit: 3 },
+    { file: 'ui-libraries.csv', column: 'Job', limit: 3 },
   ],
   meera: [
     { file: 'products.csv', column: 'Product Type', limit: 3 },
@@ -55,14 +58,17 @@ var REFERENCE_MAP = {
     { file: 'ui-reasoning.csv', column: 'UI Category', limit: 3 },
     { file: 'app-interface.csv', column: 'Keywords', limit: 3 },
     { file: 'icons.csv', column: 'Keywords', limit: 3 },
+    { file: 'ui-libraries.csv', column: 'Job', limit: 3 },
   ],
   anuj: [
     { file: 'ux-guidelines.csv', column: 'Category', limit: 3 },
     { file: 'app-interface.csv', column: 'Keywords', limit: 3 },
     { file: 'stacks/shadcn.csv', column: 'Category', limit: 3 },
+    { file: 'ui-libraries.csv', column: 'Job', limit: 3 },
   ],
   priya: [
     { file: 'react-performance.csv', column: 'Category', limit: 3 },
+    { file: 'ui-libraries.csv', column: 'Job', limit: 3 },
   ],
   raj: [
     { file: 'products.csv', column: 'Product Type', limit: 3 },
@@ -101,7 +107,9 @@ function getReferenceSpec(id, state) {
   if (!Array.isArray(specs)) specs = [specs];
   if (id === 'priya') {
     var stack = detectStack(state && state.vault_path);
-    if (stack) return [{ file: 'stacks/' + stack + '.csv', column: 'Category', limit: 3 }];
+    if (stack) {
+      return [{ file: 'stacks/' + stack + '.csv', column: 'Category', limit: 3 }].concat(specs);
+    }
   }
   return specs;
 }

package/dist/lib/session.js

@@ -49,6 +49,7 @@ function defaultState(projectId) {
     },
     information_hierarchy: { declared_by: 'undeclared', ranking: [] },
     routing_decision: { problem_type: '', experts: [], reason: '' },
+    active_run: null,
     persona_outputs: {},
     full_prompts: {},
     structured_outputs: {},
@@ -64,6 +65,13 @@ function defaultState(projectId) {
     },
     vault_path: '',
     last_collect_at: '',
+    installed_ui_libraries: {
+      installed: [],
+      missing_defaults: [],
+      full_kits: [],
+      mixed_kits: false,
+      folders: [],
+    },
     deliberation: {
       round: 0,
       max_rounds: 3,
@@ -214,11 +222,22 @@ function ensurePersonaOutput({ project, persona, text } = {}) {
   const outputs = { ...(state.persona_outputs || {}) };
   let created = false;
   if (!outputs[persona]) {
+    if (state.active_run && !text) {
+      return { projectId, state, created: false, stale: true };
+    }
+    const now = new Date().toISOString();
     outputs[persona] = {
       text: text || '(slash — designer marked this note; full text was in chat)',
-      at: new Date().toISOString(),
+      at: now,
       accepted: null,
       source: 'slash',
+      run_id: state.active_run?.id || `slash-${Date.now()}`,
+      attribution: {
+        provider: 'host',
+        model: 'unknown',
+        model_id: 'host/unknown',
+        effort: 'unknown',
+      },
     };
     created = true;
     state = update({ project: projectId, patch: { persona_outputs: outputs } });
@@ -233,7 +252,11 @@ function markAccepted({ project, persona, accepted = true } = {}) {
   if (!state || !state.persona_outputs || !state.persona_outputs[persona]) {
     return { updated: false, reason: `No output recorded for persona "${persona}" in this session yet.` };
   }
-  state.persona_outputs[persona].accepted = accepted;
+  const output = state.persona_outputs[persona];
+  if (state.active_run && output.run_id !== state.active_run.id) {
+    return { updated: false, reason: `The "${persona}" output is from an older run. Run the persona again before rating it.` };
+  }
+  output.accepted = accepted;
   const merged = update({ project: projectId, patch: { persona_outputs: state.persona_outputs } });
   return { updated: true, state: merged };
 }
@@ -246,8 +269,10 @@ function logHostTurn({ project, path: turnPath, persona, inferred_in, verdicts =
   const existing = show({ project: projectId }) || defaultState(projectId);
   const metrics = { ...(existing.metrics || {}) };
   const turns = Array.isArray(metrics.host_turns) ? metrics.host_turns.slice() : [];
+  const now = new Date().toISOString();
+  const runId = `host-${Date.now()}-${crypto.randomBytes(3).toString('hex')}`;
   turns.push({
-    at: new Date().toISOString(),
+    at: now,
     path: turnPath || 'mcp',
     persona: persona || '',
     inferred_in: Number(inferred_in) || 0,
@@ -259,7 +284,26 @@ function logHostTurn({ project, path: turnPath, persona, inferred_in, verdicts =
   const cliIn = metrics.input_tokens_est || 0;
   const v = metrics.verdicts_this_run || (metrics.experts_run && metrics.experts_run.length ? 1 : 0) || (metrics.host_turns.length ? 1 : 0);
   metrics.tokens_per_verdict = v && (host + cliIn) ? Math.round((host + cliIn) / v) : null;
-  return update({ project: projectId, patch: { metrics } });
+  const patch = { metrics };
+  if (persona && PERSONA_IDS.indexOf(persona) !== -1) {
+    patch.active_run = { id: runId, mode: 'host', at: now };
+    patch.persona_outputs = {
+      [persona]: {
+        text: '(host chat — full response remains in the IDE conversation)',
+        at: now,
+        accepted: null,
+        source: turnPath || 'mcp',
+        run_id: runId,
+        attribution: {
+          provider: 'host',
+          model: 'unknown',
+          model_id: 'host/unknown',
+          effort: 'unknown',
+        },
+      },
+    };
+  }
+  return update({ project: projectId, patch });
 }
 
 module.exports = {