analyzthis_design 2.4.0 → 2.5.0

package/dist/lib/feedback-submit.js

@@ -18,7 +18,9 @@ const CONFIG_DIR = path.join(os.homedir(), '.analyzthis_design');
 const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
 const CONSENT_FILE = path.join(CONFIG_DIR, 'feedback', 'submit-consent.json');
 
+const DEFAULT_ENDPOINT = 'https://analyzthis-lab.vercel.app/api/feedback';
 const MAX_SUBMIT_TEXT = 2000;
+const MAX_ROWS_PER_REQUEST = 50;
 const PATH_PATTERN = /(?:\/Users\/|\/home\/|[A-Za-z]:\\)[^\s"'`,;)]+/g;
 const EMAIL_PATTERN = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g;
 const SECRET_PATTERN = /\b(sk-[a-zA-Z0-9_-]{10,}|api[_-]?key\s*[:=]\s*['"]?[a-zA-Z0-9_-]{8,})/gi;
@@ -43,8 +45,11 @@ function resolveSubmitConfig() {
   const pkgVersion = safePackageVersion();
 
   return {
-    url: process.env.ANALYZTHIS_FEEDBACK_URL || fb.submit_url || '',
-    anonKey: process.env.ANALYZTHIS_FEEDBACK_ANON_KEY || fb.anon_key || '',
+    // A single HTTPS endpoint — the Vercel function in website/api/feedback.js,
+    // which holds the Neon connection string in its own env. The package never
+    // carries a database credential, and moving off Neon later means editing
+    // that function rather than republishing this package.
+    url: process.env.ANALYZTHIS_FEEDBACK_URL || fb.submit_url || DEFAULT_ENDPOINT,
     enabled: fb.submit_enabled !== false,
     packageVersion: pkgVersion,
     installId: getInstallId(config),
@@ -105,6 +110,23 @@ function anonymizeText(text, maxLen = MAX_SUBMIT_TEXT) {
   return out.trim();
 }
 
+/**
+ * Look up what actually happened to this persona's advice. The reaction
+ * (satisfied/rating) says the designer was unhappy; the outcome says the
+ * persona was wrong. Only the second justifies changing the shipped package.
+ */
+function outcomeForEntry(entry) {
+  try {
+    const state = session.show({ project: entry.project_id });
+    if (!state || !state.outcome) return null;
+    const rec = (state.outcome.confirmed && state.outcome.confirmed[entry.persona])
+      || (state.outcome.inferred && state.outcome.inferred[entry.persona]);
+    return (rec && rec.value) || null;
+  } catch {
+    return null;
+  }
+}
+
 function entryToSubmitPayload(entry, cfg) {
   return {
     install_id: cfg.installId,
@@ -113,6 +135,8 @@ function entryToSubmitPayload(entry, cfg) {
     persona: entry.persona,
     satisfied: !!entry.satisfied,
     rating: entry.rating,
+    outcome: outcomeForEntry(entry),
+    task_type: entry.context?.problem_type || '',
     tags: entry.tags || [],
     user_comment: anonymizeText(entry.comment, 800),
     assistant_rejected: anonymizeText(entry.original_output),
@@ -193,22 +217,21 @@ async function submitRows(rows, cfg) {
   if (!cfg.url) {
     throw new Error(
       'No feedback submit URL configured.\n'
-      + '  Maintainer: set feedback.submit_url + feedback.anon_key in ~/.analyzthis_design/config.json\n'
-      + '  Or env: ANALYZTHIS_FEEDBACK_URL and ANALYZTHIS_FEEDBACK_ANON_KEY\n'
-      + '  See README → "Community feedback collection"',
+      + '  Set feedback.submit_url in ~/.analyzthis_design/config.json\n'
+      + '  Or env: ANALYZTHIS_FEEDBACK_URL\n'
+      + '  See docs/package-feedback.md',
     );
   }
-  if (!cfg.anonKey) {
-    throw new Error('Missing anon key. Set feedback.anon_key in config or ANALYZTHIS_FEEDBACK_ANON_KEY.');
-  }
 
-  await postJson(cfg.url, {
-    apikey: cfg.anonKey,
-    Authorization: `Bearer ${cfg.anonKey}`,
-    Prefer: 'return=minimal',
-  }, rows);
-
-  return rows.length;
+  // No credential travels with the package. The endpoint is a Vercel function
+  // that holds the database connection string in its own environment.
+  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: 'corrections', rows: batch });
+    sent += batch.length;
+  }
+  return sent;
 }
 
 function askConsentQuestion() {
@@ -216,7 +239,8 @@ function askConsentQuestion() {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     rl.question(
       '\nShare anonymized persona feedback with analyzthis_design maintainers?\n'
-      + '  Sends: persona, rating, tags, comment/correction, redacted output snippets\n'
+      + '  Sends: persona, rating, outcome (shipped/revised/missed), task type,\n'
+      + '         tags, comment/correction, redacted output snippets\n'
       + '  Does NOT send: project paths, repo names, emails, or API keys\n'
       + 'Continue? [y/N] ',
       (answer) => {
@@ -303,19 +327,77 @@ function submitStatus() {
   return {
     consent: consent?.opted_in ? `opted in (${consent.at})` : 'not opted in',
     endpoint: cfg.url || '(not configured — set feedback.submit_url)',
-    anonKey: cfg.anonKey ? 'configured' : '(missing — set feedback.anon_key)',
+    endpoint: cfg.url || '(unset)',
     installId: cfg.installId,
     unsentCount: unsent,
     packageVersion: cfg.packageVersion,
   };
 }
 
+
+/**
+ * Aggregate persona scores — counts only, never note text.
+ * This is the signal that tells the maintainer which persona rule is failing
+ * ACROSS installs, which is the only justification for changing the shipped
+ * package. Cheap to send and hard to de-anonymise.
+ */
+function buildScorePayloads(cfg) {
+  const em = require('./evolution-metrics');
+  const metrics = em.computeEvolutionMetrics();
+  const rows = [];
+  for (const [persona, m] of Object.entries(metrics.personas)) {
+    // Nothing learned yet — do not ship noise upstream.
+    if (!m.evidence_count) continue;
+    rows.push({
+      install_id: cfg.installId,
+      package_version: cfg.packageVersion,
+      persona,
+      score: m.score,
+      level: m.level,
+      evidence_count: m.evidence_count,
+      shipped: m.outcome_breakdown.shipped || 0,
+      revised: m.outcome_breakdown.revised || 0,
+      blocked_correctly: m.outcome_breakdown.blocked_correctly || 0,
+      missed: m.outcome_breakdown.missed || 0,
+      avg_rating: m.avg_rating,
+    });
+  }
+  return rows;
+}
+
+/**
+ * Send the aggregate scoreboard. Requires the same consent as corrections.
+ */
+async function submitScores({ dryRun = false } = {}) {
+  const cfg = resolveSubmitConfig();
+  if (!cfg.enabled) return { sent: 0, skipped: 'submission disabled' };
+
+  const rows = buildScorePayloads(cfg);
+  if (!rows.length) return { sent: 0, skipped: 'no scored personas yet' };
+  if (dryRun) return { sent: 0, dryRun: true, rows };
+
+  if (!loadConsent()) return { sent: 0, skipped: 'no consent on file' };
+  if (!cfg.url) return { sent: 0, skipped: 'no endpoint configured' };
+
+  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: 'scores', rows: batch });
+    sent += batch.length;
+  }
+  return { sent, rows };
+}
+
 module.exports = {
   anonymizeText,
   entryToSubmitPayload,
   resolveSubmitConfig,
   submitFeedback,
+  submitScores,
+  buildScorePayloads,
   submitStatus,
+  collectUnsentEntries,
+  markEntriesSubmitted,
   loadConsent,
   saveConsent,
   revokeConsent,

package/dist/lib/host-llm.js

@@ -76,9 +76,25 @@ function responsePath(runDir, stepId) {
   return path.join(runDir, 'responses', `${stepId}.md`);
 }
 
+/**
+ * Devi voices every persona, so it is the one place a team-wide trust signal
+ * can land. Advisory only — Devi weights its synthesis, never drops a persona.
+ * Best-effort: a scoreboard must never block a run.
+ */
+function scoreboardPreamble() {
+  try {
+    const em = require('./evolution-metrics');
+    const board = em.formatScoreboardForDevi(em.computeEvolutionMetrics());
+    return board ? board + '\n\n' : '';
+  } catch (e) {
+    return '';
+  }
+}
+
 function writePending(runDir, manifest, { personaId, system, user, meta = {} }) {
   manifest.pending_persona = personaId;
   const stepId = `${String(manifest.step_counter + 1).padStart(3, '0')}-${personaId}`;
+  system = scoreboardPreamble() + (system || '');
   const payload = {
     step_id: stepId,
     persona_id: personaId,

package/dist/lib/install.js

@@ -34,6 +34,8 @@ const PROJECT_COMMANDS = [
   'getting-started',
   'devi',
   'receipt',
+  'accept',
+  'share',
 ];
 
 const SKILLS = [
@@ -62,6 +64,8 @@ const SKILLS = [
   'design-reference',
   'knowledge-bank',
   'receipt',
+  'accept',
+  'share',
 ];
 
 function getPackageVersion() {
@@ -129,6 +133,9 @@ function printWelcomeBanner(targetId, log = console.log) {
   log(`    ${p}design-critic            4-persona critique + composite score`);
   log(`    ${p}deliberation-protocol    adversarial review rules (objections, Raj)`);
   log(`    ${p}devi                     host LLM: voice personas when CLI has no API keys`);
+  log(`    ${p}accept                   keep or skip the last note (yes / no) — local evolution`);
+  log(`    ${p}share                    send a correction to the package (preview, then yes)`);
+  log(`    ${p}receipt                  inferred tokens for this project (not a bill)`);
 
   log('');
   log('  CLI (host mode — no API keys):');

package/dist/lib/lessons.js

@@ -32,10 +32,26 @@ function loadLessons(personaId) {
   return lessons;
 }
 
+function lessonKey(lesson) {
+  return [lesson.persona, lesson.session_id, lesson.polarity || '', lesson.pattern].join('|');
+}
+
+/**
+ * Append unless an identical lesson already exists. Lessons now feed scoring
+ * (+10 each), and extractLessons runs on every keep/skip, so re-marking the
+ * same note must not inflate a persona's score.
+ * @returns {boolean} true if written
+ */
 function appendLesson(personaId, lesson) {
   ensureLessonsDir();
   var file = personaLessonFile(personaId);
+  var key = lessonKey(lesson);
+  var existing = loadLessons(personaId);
+  for (var i = 0; i < existing.length; i++) {
+    if (lessonKey(existing[i]) === key) return false;
+  }
   fs.appendFileSync(file, JSON.stringify(lesson) + '\n');
+  return true;
 }
 
 function keywordOverlap(a, b) {
@@ -52,7 +68,10 @@ function keywordOverlap(a, b) {
 
 function extractLessonsFromSession(state, personaId) {
   var entry = state.persona_outputs && state.persona_outputs[personaId];
-  if (!entry || entry.accepted !== true) return [];
+  // Learn from rejections too — a correction is the most informative signal
+  // we get. accepted === null means the designer never reacted; skip those.
+  if (!entry || entry.accepted === null || entry.accepted === undefined) return [];
+  var polarity = entry.accepted === true ? 'positive' : 'negative';
 
   var outcomeVal = 'unknown';
   if (state.outcome && state.outcome.confirmed && state.outcome.confirmed[personaId]) {
@@ -80,6 +99,7 @@ function extractLessonsFromSession(state, personaId) {
           pattern: pattern,
           fix: fix,
           outcome: outcomeVal,
+          polarity: polarity,
           session_id: state.project_id,
           extracted_at: new Date().toISOString(),
           citation: entry.citations ? entry.citations[0] : ''
@@ -88,6 +108,30 @@ function extractLessonsFromSession(state, personaId) {
     }
   }
 
+  // A rejection carries the designer's own correction — the highest-value
+  // lesson available. Pull it from the most recent negative feedback entry.
+  if (polarity === 'negative') {
+    var log = state.feedback_log || [];
+    for (var f = log.length - 1; f >= 0; f--) {
+      if (log[f].persona !== personaId || log[f].satisfied !== false) continue;
+      var corrective = String(log[f].correction || log[f].comment || '').trim();
+      if (!corrective) break;
+      lessons.push({
+        id: require('crypto').randomBytes(6).toString('hex'),
+        persona: personaId,
+        task_type: state.task_type || '',
+        pattern: 'Designer rejected this note: ' + corrective,
+        fix: corrective,
+        outcome: outcomeVal,
+        polarity: 'negative',
+        session_id: state.project_id,
+        extracted_at: new Date().toISOString(),
+        citation: ''
+      });
+      break;
+    }
+  }
+
   var hierarchyMatch = text.match(/Hierarchy\[([A-F])\]/gi);
   if (hierarchyMatch) {
     for (var j = 0; j < hierarchyMatch.length; j++) {
@@ -99,6 +143,7 @@ function extractLessonsFromSession(state, personaId) {
         pattern: pattern2,
         fix: 'Review visual hierarchy per DS tokens',
         outcome: outcomeVal,
+        polarity: polarity,
         session_id: state.project_id,
         extracted_at: new Date().toISOString(),
         citation: ''
@@ -123,8 +168,7 @@ function extractLessons(opts) {
 
     var lessons = extractLessonsFromSession(state, persona);
     for (var j = 0; j < lessons.length; j++) {
-      appendLesson(persona, lessons[j]);
-      total++;
+      if (appendLesson(persona, lessons[j])) total++;
     }
   }
 
@@ -148,8 +192,7 @@ function extractAllLessons(opts) {
       var pers = personas[p];
       var lessons = extractLessonsFromSession(state, pers);
       for (var j = 0; j < lessons.length; j++) {
-        appendLesson(pers, lessons[j]);
-        total++;
+        if (appendLesson(pers, lessons[j])) total++;
       }
     }
   }

package/dist/lib/mcp-server.js

@@ -268,9 +268,12 @@ var TOOLS = [
     inputSchema: {
       type: 'object',
       properties: {
-        action: { type: 'string', enum: ['show', 'init', 'reset', 'accept'], description: 'show: display current state; init: create fresh; reset: delete; accept: mark a persona output as accepted' },
-        persona: { type: 'string', description: 'Persona ID (for accept action)' },
-        reject: { type: 'boolean', description: 'Reject instead of accept (for accept action)' },
+        action: { type: 'string', enum: ['show', 'init', 'reset', 'accept'], description: 'show: display current state; init: create fresh; reset: delete; accept: keep or skip a persona note (designer /accept)' },
+        persona: { type: 'string', description: 'Persona ID (for accept action). Optional — last persona if omitted.' },
+        reject: { type: 'boolean', description: 'Skip / fix instead of keep (for accept action)' },
+        because: { type: 'string', description: 'One sentence: what was wrong or what you did instead (when reject is true)' },
+        comment: { type: 'string', description: 'Optional note on keep, or alias for because on skip' },
+        shipped: { type: 'boolean', description: 'On keep: mark shipped (default true). False = liked only.' },
       },
       required: ['action'],
     },
@@ -287,6 +290,29 @@ var TOOLS = [
   },
 ];
 
+// The one line every persona closes with. Deliberately host-neutral: the
+// designer answers in plain language and the agent picks the transport
+// (Bash on Claude Code/Cursor, analyzthis_accept on Desktop).
+var ASK_LINE = '\u2014\nWas this right? Say yes, or no plus one sentence. I\'ll record it.';
+
+var ACCEPT_TOOL = {
+  name: 'analyzthis_accept',
+  description: 'Record the designer\'s reaction to a persona note. Call this whenever they approve, '
+    + 'push back on, or correct a persona (\"that\'s right\", \"no, the hierarchy is backwards\"). '
+    + 'This is how personas earn or lose trust — without it they never improve. '
+    + 'persona is optional: the last one that spoke is inferred.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      keep: { type: 'boolean', description: 'true = the note was right; false = it was wrong or needed rework' },
+      persona: { type: 'string', description: 'Optional. zara, arjun, meera, priya, noor, anuj, raj, kavi. Inferred if omitted.' },
+      because: { type: 'string', description: 'Required when keep is false: one sentence on what was wrong or what they did instead' },
+      comment: { type: 'string', description: 'Optional note when keep is true' },
+    },
+    required: ['keep'],
+  },
+};
+
 var ROUTER_TOOL = {
   name: 'analyzthis_design',
   description: 'Design team router. Set who to zara, arjun, noor, anuj, meera, priya, raj, kavi, orchestrator, ux-ideator, design-critic, ux-story-gate, design-director, or mood-board. Returns a short skill front — call analyzthis_retrieve for the rest.',
@@ -303,7 +329,14 @@ var ROUTER_TOOL = {
 
 var RECEIPT_TOOL = {
   name: 'analyzthis_receipt',
-  description: 'Show inferred token receipt for this project. Not a bill. Do not invent a dollar figure.',
+  description: 'Show inferred token receipt for this project, and optionally how much each persona is worth listening to. Not a bill. Do not invent a dollar figure.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      project: { type: 'string', description: 'Optional project id' },
+      scores: { type: 'boolean', description: 'Include the persona trust scoreboard' },
+    },
+  },
   inputSchema: {
     type: 'object',
     properties: {
@@ -319,9 +352,9 @@ function resolveCatalog(explicit) {
 
 function listedTools(catalog) {
   if (resolveCatalog(catalog) === 'full') {
-    return TOOLS.concat([ROUTER_TOOL, RECEIPT_TOOL]);
+    return TOOLS.concat([ROUTER_TOOL, ACCEPT_TOOL, RECEIPT_TOOL]);
   }
-  return [ROUTER_TOOL, TOOLS.find(function (t) { return t.name === 'analyzthis_retrieve'; }), TOOLS.find(function (t) { return t.name === 'analyzthis_session'; }), RECEIPT_TOOL].filter(Boolean);
+  return [ROUTER_TOOL, ACCEPT_TOOL, TOOLS.find(function (t) { return t.name === 'analyzthis_retrieve'; }), TOOLS.find(function (t) { return t.name === 'analyzthis_session'; }), RECEIPT_TOOL].filter(Boolean);
 }
 
 // ── Tool handlers ────────────────────────────────────────────────────────
@@ -369,6 +402,8 @@ function handleToolCall(name, args) {
       return handleRouter(args);
     case 'analyzthis_receipt':
       return handleReceipt(args);
+    case 'analyzthis_accept':
+      return handleAccept(args);
 
     default:
       return { error: 'Unknown tool: ' + name };
@@ -395,7 +430,8 @@ function handleSinglePersona(personaId, args) {
     (context ? '\n## Context\n' + context : '') +
     extra + '\n\n' +
     'Use the lite output contract. Call analyzthis_retrieve (kind=skill, file=' + personaId + ') only if you need the full lens. ' +
-    'Be specific — cite components, zones, and fixes. Do not give generic advice.';
+    'Be specific — cite components, zones, and fixes. Do not give generic advice.\n\n' +
+    'End your reply with this line, exactly:\n' + ASK_LINE;
 
   return { prompt: prompt, persona: personaId, task: task, verdicts: 1 };
 }
@@ -568,9 +604,43 @@ function handleRouter(args) {
   return handleCombinationPass(mapped, args);
 }
 
+function handleAccept(args) {
+  try {
+    var accept = require('./accept');
+    if (args.keep === false) {
+      return { result: JSON.stringify(accept.fix({
+        project: args.project,
+        persona: args.persona,
+        because: args.because || args.comment || '',
+      })) };
+    }
+    return { result: JSON.stringify(accept.keep({
+      project: args.project,
+      persona: args.persona,
+      comment: args.comment || '',
+      shipped: args.shipped !== false,
+    })) };
+  } catch (e) {
+    if (e.code === 'NEED_PERSONA') {
+      return { result: 'Which persona was that — Zara, Arjun, Meera, Priya, Noor, Anuj, or Raj? Ask the designer, then call again.' };
+    }
+    if (e.code === 'NEED_BECAUSE') {
+      return { result: 'Ask the designer one sentence on what was wrong, then call again with because.' };
+    }
+    return { error: e.message };
+  }
+}
+
 function handleReceipt(args) {
   var receipt = require('./receipt');
-  return { result: receipt.report({ project: args.project }) };
+  var out = receipt.report({ project: args.project });
+  if (args.scores) {
+    try {
+      var em = require('./evolution-metrics');
+      out += '\n\n' + em.formatEvolutionSummary(em.computeEvolutionMetrics());
+    } catch (e) { /* receipt must never fail for a scoreboard */ }
+  }
+  return { result: out };
 }
 
 function handleSession(args) {
@@ -591,9 +661,18 @@ function handleSession(args) {
       return { result: 'Session reset.' };
     }
     if (action === 'accept') {
-      if (!args.persona) return { error: 'persona is required for accept' };
-      var result = session.markAccepted({ persona: args.persona, accepted: !args.reject });
-      return { result: JSON.stringify(result) };
+      var accept = require('./accept');
+      if (args.reject) {
+        return { result: JSON.stringify(accept.fix({
+          persona: args.persona,
+          because: args.because || args.comment || '',
+        })) };
+      }
+      return { result: JSON.stringify(accept.keep({
+        persona: args.persona,
+        comment: args.comment || '',
+        shipped: args.shipped !== false,
+      })) };
     }
   } catch (e) {
     return { error: e.message };

package/dist/lib/receipt.js

@@ -0,0 +1,102 @@
+'use strict';
+
+/**
+ * Inferred token receipts for Claude-path (slash / MCP) turns.
+ * Never call this a bill. Never multiply into a monthly dollar. Never say verified.
+ */
+
+var session = require('./session');
+
+var HOST_TURNS_CAP = 40;
+var CHARS_PER_TOKEN = 4;
+
+function inferTokens(text) {
+  return Math.ceil(String(text || '').length / CHARS_PER_TOKEN);
+}
+
+function formatFooter(inferredIn) {
+  return (
+    '\n\n---\nInferred context this turn: ' +
+    inferredIn +
+    ' tokens (not a bill). Do not invent a dollar figure.'
+  );
+}
+
+function wrapPayload(text, meta) {
+  var body = String(text || '');
+  var inferredIn = inferTokens(body);
+  try {
+    session.logHostTurn({
+      path: (meta && meta.path) || 'mcp',
+      persona: (meta && meta.persona) || '',
+      inferred_in: inferredIn,
+      project: meta && meta.project,
+      verdicts: (meta && meta.verdicts) || 0,
+    });
+  } catch (e) {
+    // Session write is best-effort — never fail a tool call for a receipt.
+  }
+  return body + formatFooter(inferredIn);
+}
+
+function tokensPerVerdict(state) {
+  if (!state || !state.metrics) return null;
+  var m = state.metrics;
+  var host = (m.host_turns || []).reduce(function (sum, turn) {
+    return sum + (turn.inferred_in || 0);
+  }, 0);
+  var cliIn = m.input_tokens_est || 0;
+  var totalIn = host + cliIn;
+  var verdicts = m.verdicts_this_run || 0;
+  if (!verdicts && (m.experts_run || []).length) verdicts = 1;
+  if (!verdicts && (m.host_turns || []).length) verdicts = 1;
+  if (!verdicts || !totalIn) return null;
+  return Math.round(totalIn / verdicts);
+}
+
+function formatReport(state) {
+  if (!state) {
+    return 'No session found. Run: npx analyzthis_design session init';
+  }
+  var m = state.metrics || {};
+  var turns = m.host_turns || [];
+  var tpv = tokensPerVerdict(state);
+  var lines = [
+    'Receipt — inferred, not a bill',
+    'Project: ' + (state.project_id || ''),
+    'CLI est. tokens: ' + (m.input_tokens_est || 0) + ' in / ' + (m.output_tokens_est || 0) + ' out',
+    'Host turns logged: ' + turns.length,
+  ];
+  turns.slice(-8).forEach(function (turn) {
+    lines.push(
+      '  ' +
+        (turn.at || '') +
+        '  ' +
+        (turn.path || '') +
+        '  ' +
+        (turn.persona || '-') +
+        '  ' +
+        (turn.inferred_in || 0) +
+        ' tok'
+    );
+  });
+  if (tpv != null) lines.push('Tokens per verdict: ' + tpv + ' (inferred + CLI est. input / verdicts)');
+  else lines.push('Tokens per verdict: n/a — no host turn or CLI run yet');
+  lines.push('You cannot know Claude’s real usage from slash alone. Do not invent a dollar figure.');
+  return lines.join('\n');
+}
+
+function report(opts) {
+  var state = session.show({ project: opts && opts.project });
+  return formatReport(state);
+}
+
+module.exports = {
+  inferTokens: inferTokens,
+  formatFooter: formatFooter,
+  wrapPayload: wrapPayload,
+  tokensPerVerdict: tokensPerVerdict,
+  formatReport: formatReport,
+  report: report,
+  HOST_TURNS_CAP: HOST_TURNS_CAP,
+};

package/dist/lib/session.js

@@ -177,8 +177,58 @@ function listProjects() {
  * lightweight feedback flag the future LoRA training-pair export reads.
  * No-ops if the persona hasn't produced an output yet.
  */
+const PERSONA_IDS = ['arjun', 'meera', 'priya', 'zara', 'noor', 'anuj', 'raj', 'kavi'];
+
+function inferLastPersona({ project } = {}) {
+  const state = show({ project: project || getProjectId() });
+  if (!state) return null;
+  const turns = (state.metrics && state.metrics.host_turns) || [];
+  for (let i = turns.length - 1; i >= 0; i--) {
+    const id = turns[i] && turns[i].persona;
+    if (id && PERSONA_IDS.indexOf(id) !== -1) return id;
+  }
+  const outputs = state.persona_outputs || {};
+  let best = null;
+  let bestAt = '';
+  Object.keys(outputs).forEach((id) => {
+    const at = (outputs[id] && outputs[id].at) || '';
+    if (at >= bestAt) {
+      bestAt = at;
+      best = id;
+    }
+  });
+  if (best) return best;
+  const experts = state.routing_decision && state.routing_decision.experts;
+  if (Array.isArray(experts) && experts[0]) return experts[0];
+  return null;
+}
+
+// Slash / MCP notes often never write persona_outputs. Create a stub so keep/fix still works.
+function ensurePersonaOutput({ project, persona, text } = {}) {
+  const projectId = project || getProjectId();
+  let state = show({ project: projectId });
+  if (!state) {
+    init({ project: projectId });
+    state = show({ project: projectId });
+  }
+  const outputs = { ...(state.persona_outputs || {}) };
+  let created = false;
+  if (!outputs[persona]) {
+    outputs[persona] = {
+      text: text || '(slash — designer marked this note; full text was in chat)',
+      at: new Date().toISOString(),
+      accepted: null,
+      source: 'slash',
+    };
+    created = true;
+    state = update({ project: projectId, patch: { persona_outputs: outputs } });
+  }
+  return { projectId, state, created };
+}
+
 function markAccepted({ project, persona, accepted = true } = {}) {
   const projectId = project || getProjectId();
+  ensurePersonaOutput({ project: projectId, persona });
   const state = show({ project: projectId });
   if (!state || !state.persona_outputs || !state.persona_outputs[persona]) {
     return { updated: false, reason: `No output recorded for persona "${persona}" in this session yet.` };
@@ -213,5 +263,6 @@ function logHostTurn({ project, path: turnPath, persona, inferred_in, verdicts =
 }
 
 module.exports = {
-  getProjectId, sessionPath, sessionDir, init, show, reset, update, listProjects, markAccepted, logHostTurn, SESSIONS_ROOT,
+  getProjectId, sessionPath, sessionDir, init, show, reset, update, listProjects,
+  markAccepted, ensurePersonaOutput, inferLastPersona, PERSONA_IDS, logHostTurn, SESSIONS_ROOT,
 };