analyzthis_design 2.3.1 → 2.4.1

package/dist/lib/knowledge.js

@@ -8,12 +8,10 @@ const crypto = require('crypto');
 
 const CONFIG_DIR        = path.join(os.homedir(), '.analyzthis_design');
 const CONFIG_FILE       = path.join(CONFIG_DIR, 'config.json');
-// When published, this file lives at dist/lib/ — go up two levels to reach package root
-const KNOWLEDGE_SKILL   = path.join(__dirname, '..', '..', 'skills', 'knowledge-bank', 'SKILL.md');
-const KNOWLEDGE_SLICE_ROOT = path.join(CONFIG_DIR, 'kb-slices');
-
 const { resolvePackageRoot } = require('./platforms');
 const PACKAGE_ROOT = resolvePackageRoot(__dirname);
+const KNOWLEDGE_SKILL   = path.join(PACKAGE_ROOT, 'skills', 'knowledge-bank', 'SKILL.md');
+const KNOWLEDGE_SLICE_ROOT = path.join(CONFIG_DIR, 'kb-slices');
 const AGENTS_DIR = path.join(PACKAGE_ROOT, 'agents');
 
 // Keywords used to auto-group vault notes into categories
@@ -326,41 +324,74 @@ function sync({ targets = ['cursor'], project, global = false, cwd } = {}) {
     ? 'global (merged across projects)'
     : `project: ${scopeInfo.projectId}`;
 
-  let md = `---
-name: knowledge-bank
-description: Personal knowledge bank — takes precedence over all built-in persona defaults.
+  let fullMd = `---
+name: knowledge-bank-full
+description: Full project notes. Do not load this file into chat. Retrieve one persona slice instead.
 disable-model-invocation: true
 ---
 
-# Knowledge Bank
+# Knowledge Bank (full dump — do not inject)
 
 > Last synced: ${date}
 > Scope: ${scopeLabel}
 > Sources: ${sourceList}
 > Files loaded: ${totalFiles}
 
-**INSTRUCTION TO ALL PERSONAS:** This knowledge bank contains project-specific context that overrides your built-in defaults. Read every section below before forming any opinion. When this knowledge bank conflicts with your built-in knowledge, this knowledge bank wins.
-
----
-
 `;
 
   let hasContent = false;
+  let indexLines = '';
   for (const { key, heading } of sectionDefs) {
     if (sections[key].length === 0) continue;
     hasContent = true;
-    md += `${heading}\n\n`;
+    fullMd += `${heading}\n\n`;
+    indexLines += `${heading}\n`;
     for (const note of sections[key]) {
-      md += `### ${note.title}\n\n${note.content}\n\n`;
+      fullMd += `### ${note.title}\n\n${note.content}\n\n`;
+      indexLines += `- ${note.title}\n`;
     }
-    md += '---\n\n';
+    fullMd += '---\n\n';
+    indexLines += '\n';
   }
 
   if (!hasContent) {
-    md += `_No matching files found. Check your --tags or --include filters, or remove filters to include all notes._\n`;
+    fullMd += `_No matching files found. Check your --tags or --include filters, or remove filters to include all notes._\n`;
+    indexLines += `_No notes yet. Run collect/sync first._\n`;
   }
 
-  // Write to the package's own skills/knowledge-bank/SKILL.md (source of truth)
+  const md = `---
+name: knowledge-bank
+description: Project knowledge index — retrieve one persona slice. Do not load the full bank.
+disable-model-invocation: true
+---
+
+# Knowledge Bank
+
+> Last synced: ${date}
+> Scope: ${scopeLabel}
+> Sources: ${sourceList}
+> Files loaded: ${totalFiles}
+
+**INSTRUCTION TO ALL PERSONAS:** Load your persona slice via retrieve. Do not load the whole bank. When a slice conflicts with built-in defaults, the slice wins.
+
+\`\`\`
+npx analyzthis_design retrieve — or MCP analyzthis_retrieve
+  kind=knowledge  persona=arjun|meera|priya|zara|noor|anuj|raj|kavi
+\`\`\`
+
+You cannot know host tokens. Do not invent a dollar figure.
+
+## Index (titles only)
+
+${indexLines}
+`;
+
+  // Full dump stays on disk for retrieve; the skill is an index only.
+  const projectIdForFull = scopeInfo.projectId || 'default';
+  const fullDir = path.join(KNOWLEDGE_SLICE_ROOT, projectIdForFull);
+  fs.mkdirSync(fullDir, { recursive: true });
+  fs.writeFileSync(path.join(fullDir, 'full.md'), fullMd);
+
   fs.mkdirSync(path.dirname(KNOWLEDGE_SKILL), { recursive: true });
   fs.writeFileSync(KNOWLEDGE_SKILL, md);
 
@@ -470,7 +501,7 @@ function buildPersonaSlice(personaId, sections, sectionDefs, projectId) {
 }
 
 function writePersonaSlices(sections, sectionDefs, projectId) {
-  const personas = ['arjun', 'meera', 'priya', 'zara', 'noor', 'anuj', 'raj'];
+  const personas = ['arjun', 'meera', 'priya', 'zara', 'noor', 'anuj', 'raj', 'kavi'];
   const dir = path.join(KNOWLEDGE_SLICE_ROOT, projectId || 'default');
   fs.mkdirSync(dir, { recursive: true });
   const written = [];

package/dist/lib/mcp-server.js

@@ -248,16 +248,18 @@ var TOOLS = [
   },
   {
     name: 'analyzthis_retrieve',
-    description: 'Retrieve CSV reference data. Query the 28-file reference library (colors, styles, typography, UX guidelines, charts, products, landing patterns, 16 stack guides). Returns filtered, citation-ready rows.',
+    description: 'Retrieve on demand: CSV rows, a skill reference file, or one knowledge-bank persona slice. Do not load the full bank.',
     inputSchema: {
       type: 'object',
       properties: {
-        file: { type: 'string', description: 'CSV filename (e.g., "styles.csv", "colors.csv", "stacks/nextjs.csv")' },
-        column: { type: 'string', description: 'Column to filter on (e.g., "Product Type", "Category", "Best For Tags")' },
-        keywords: { type: 'string', description: 'Comma-separated keywords to match (e.g., "saas,dashboard")' },
-        limit: { type: 'number', description: 'Max rows to return (default: 3)' },
+        kind: { type: 'string', enum: ['csv', 'skill', 'knowledge'], description: 'csv (default), skill (references/*.md), or knowledge (one persona slice)' },
+        file: { type: 'string', description: 'CSV filename, or skill id (e.g. arjun), or knowledge/<persona>' },
+        column: { type: 'string', description: 'CSV column to filter on' },
+        keywords: { type: 'string', description: 'Comma-separated CSV keywords' },
+        limit: { type: 'number', description: 'Max CSV rows (default: 3)' },
+        persona: { type: 'string', description: 'Persona id for knowledge slice (arjun, zara, …)' },
+        ref: { type: 'string', description: 'Skill reference filename without path (e.g. lens.md)' },
       },
-      required: ['file'],
     },
   },
   {
@@ -266,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'],
     },
@@ -285,6 +290,43 @@ var TOOLS = [
   },
 ];
 
+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.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      who: { type: 'string', description: 'Persona or pass name (e.g. zara, arjun, orchestrator)' },
+      task: { type: 'string', description: 'What to design or critique' },
+      context: { type: 'string', description: 'Optional extra context' },
+    },
+    required: ['who', 'task'],
+  },
+};
+
+var RECEIPT_TOOL = {
+  name: 'analyzthis_receipt',
+  description: 'Show inferred token receipt for this project. Not a bill. Do not invent a dollar figure.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      project: { type: 'string', description: 'Optional project id override' },
+    },
+  },
+};
+
+function resolveCatalog(explicit) {
+  var raw = explicit || process.env.ANALYZTHIS_MCP_CATALOG || 'lite';
+  return String(raw).toLowerCase() === 'full' ? 'full' : 'lite';
+}
+
+function listedTools(catalog) {
+  if (resolveCatalog(catalog) === 'full') {
+    return TOOLS.concat([ROUTER_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);
+}
+
 // ── Tool handlers ────────────────────────────────────────────────────────
 
 function handleToolCall(name, args) {
@@ -326,6 +368,10 @@ function handleToolCall(name, args) {
       return handleSession(args);
     case 'analyzthis_system_prompt':
       return handleSystemPrompt(args);
+    case 'analyzthis_design':
+      return handleRouter(args);
+    case 'analyzthis_receipt':
+      return handleReceipt(args);
 
     default:
       return { error: 'Unknown tool: ' + name };
@@ -333,7 +379,7 @@ function handleToolCall(name, args) {
 }
 
 function handleSinglePersona(personaId, args) {
-  var card = readCard(personaId);
+  var card = readSkillFront(personaId);
   if (!card) return { error: 'Persona not found: ' + personaId };
 
   var task = args.task || '';
@@ -351,11 +397,10 @@ function handleSinglePersona(personaId, args) {
     '## Task\n' + task + '\n' +
     (context ? '\n## Context\n' + context : '') +
     extra + '\n\n' +
-    'Produce your output following the schema in your card above. ' +
-    'Be specific — cite components, zones, and fixes. ' +
-    'Do not give generic advice.';
+    '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.';
 
-  return { prompt: prompt, persona: personaId, task: task };
+  return { prompt: prompt, persona: personaId, task: task, verdicts: 1 };
 }
 
 function handleCombinationPass(skillId, args) {
@@ -381,11 +426,11 @@ function handleCombinationPass(skillId, args) {
     skill + '\n\n' +
     '## Task\n' + task + '\n' +
     (context ? '\n## Context\n' + context : '') + '\n\n' +
-    'Run all phases sequentially. Challenge the premise first. ' +
-    'Resolve any persona disagreements explicitly — pick a winner with a forward path. ' +
-    'Produce the final output in the format specified by the skill.';
+    'Run the smallest useful team. Challenge the premise first. ' +
+    'Call analyzthis_retrieve (kind=skill, file=' + skillId + ') if the front is not enough. ' +
+    'Lite default: verdict + top 3 + one evidence line. Expand only if the user says expand.';
 
-  return { prompt: prompt, skill: skillId, task: task };
+  return { prompt: prompt, skill: skillId, task: task, persona: skillId, verdicts: 1 };
 }
 
 function handleMoodBoard(args) {
@@ -439,10 +484,13 @@ function handleCollect(args) {
 }
 
 function handleRetrieve(args) {
+  var kind = args.kind || 'csv';
+  if (kind === 'skill') return handleRetrieveSkill(args);
+  if (kind === 'knowledge') return handleRetrieveKnowledge(args);
   try {
     var retrieve = require('./retrieve');
     var file = args.file;
-    if (!file) return { error: 'file is required' };
+    if (!file) return { error: 'file is required for CSV retrieve' };
     var filters = [];
     if (args.column && args.keywords) {
       filters.push({ column: args.column, anyOf: args.keywords.split(',').map(function(s) { return s.trim(); }) });
@@ -464,6 +512,70 @@ function handleRetrieve(args) {
   }
 }
 
+function handleRetrieveSkill(args) {
+  var id = String(args.file || args.persona || '').replace(/^skill\//, '');
+  if (!id) return { error: 'file (skill id) is required' };
+  var refName = args.ref || 'lens.md';
+  var refPath = path.join(PACKAGE_ROOT, 'skills', id, 'references', refName);
+  if (!fs.existsSync(refPath)) {
+    var dir = path.join(PACKAGE_ROOT, 'skills', id, 'references');
+    if (fs.existsSync(dir)) {
+      var names = fs.readdirSync(dir).filter(function (n) { return n.endsWith('.md'); });
+      if (names.length) refPath = path.join(dir, names[0]);
+    }
+  }
+  if (!fs.existsSync(refPath)) {
+    var full = readSkill(id);
+    if (!full) return { error: 'No skill references for ' + id };
+    return { result: full, persona: id };
+  }
+  return { result: fs.readFileSync(refPath, 'utf8'), persona: id };
+}
+
+function handleRetrieveKnowledge(args) {
+  var persona = args.persona || String(args.file || '').replace(/^knowledge\//, '');
+  if (!persona) return { error: 'persona is required for knowledge retrieve' };
+  try {
+    var knowledge = require('./knowledge');
+    var sessionMod = require('./session');
+    var projectId = sessionMod.getProjectId();
+    var slicePath = path.join(knowledge.KNOWLEDGE_SLICE_ROOT, projectId, persona + '.md');
+    if (!fs.existsSync(slicePath)) {
+      return { result: 'No knowledge slice for ' + persona + '. Run collect/sync first. Do not load a full bank.' };
+    }
+    var text = fs.readFileSync(slicePath, 'utf8');
+    var cap = 6000;
+    if (text.length > cap) text = text.slice(0, cap) + '\n…[truncated — this is one slice, not the full bank]';
+    return { result: text, persona: persona };
+  } catch (e) {
+    return { error: e.message };
+  }
+}
+
+var ROUTER_WHO = {
+  zara: 'persona', arjun: 'persona', meera: 'persona', priya: 'persona',
+  noor: 'persona', anuj: 'persona', raj: 'persona', kavi: 'persona',
+  orchestrator: 'persona-orchestrator', 'persona-orchestrator': 'persona-orchestrator',
+  'ux-ideator': 'ux-ideator', 'design-critic': 'design-critic',
+  'ux-story-gate': 'ux-story-gate', 'design-director': 'design-director',
+  'mood-board': 'mood-board',
+};
+
+function handleRouter(args) {
+  var who = String(args.who || '').toLowerCase().replace(/^analyzthis_/, '').replace(/_/g, '-');
+  if (!who) return { error: 'who is required (e.g. zara, arjun, orchestrator)' };
+  var mapped = ROUTER_WHO[who];
+  if (!mapped) return { error: 'Unknown who: ' + who + '. Use a persona or orchestrator / ux-ideator / design-critic / ux-story-gate / design-director / mood-board.' };
+  if (mapped === 'persona') return handleSinglePersona(who, args);
+  if (mapped === 'mood-board') return handleMoodBoard(args);
+  return handleCombinationPass(mapped, args);
+}
+
+function handleReceipt(args) {
+  var receipt = require('./receipt');
+  return { result: receipt.report({ project: args.project }) };
+}
+
 function handleSession(args) {
   try {
     var session = require('./session');
@@ -482,9 +594,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 };
@@ -506,18 +627,16 @@ function handleSystemPrompt(args) {
 
 // ── Helpers ──
 
-function readCard(id) {
-  var p = path.join(PACKAGE_ROOT, 'agents', 'cards', id + '.md');
-  if (!fs.existsSync(p)) return null;
-  return fs.readFileSync(p, 'utf8');
-}
-
 function readSkill(id) {
   var p = path.join(PACKAGE_ROOT, 'skills', id, 'SKILL.md');
   if (!fs.existsSync(p)) return null;
   return fs.readFileSync(p, 'utf8');
 }
 
+function readSkillFront(id) {
+  return readSkill(id);
+}
+
 // ── MCP config writer ──
 
 function mergeMcpServer(configPath) {
@@ -532,6 +651,7 @@ function mergeMcpServer(configPath) {
   config.mcpServers['analyzthis_design'] = {
     command: 'npx',
     args: ['analyzthis_design', 'mcp'],
+    env: { ANALYZTHIS_MCP_CATALOG: process.env.ANALYZTHIS_MCP_CATALOG || 'lite' },
   };
   fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
   return configPath;
@@ -542,13 +662,17 @@ function looksLikeProjectCwd() {
   return fs.existsSync(path.join(cwd, 'package.json')) || fs.existsSync(path.join(cwd, '.git'));
 }
 
-function writeMcpConfig(target) {
+function writeMcpConfig(target, opts) {
+  opts = opts || {};
+  if (opts.catalog) process.env.ANALYZTHIS_MCP_CATALOG = opts.catalog;
   var home = os.homedir();
 
   if (target === 'cursor') {
     var cursorConfigPath = path.join(home, '.cursor', 'mcp.json');
     mergeMcpServer(cursorConfigPath);
     console.log('Cursor MCP config written to ' + cursorConfigPath);
+    console.log('Default MCP catalog is lite (router + retrieve + session + receipt).');
+    console.log('Full 19-tool list: ANALYZTHIS_MCP_CATALOG=full or mcp --catalog full');
     console.log('Restart Cursor to activate.\n');
     return true;
   }
@@ -575,6 +699,7 @@ function writeMcpConfig(target) {
       console.log('Project MCP config written to ' + projectMcp);
     }
 
+    console.log('Default MCP catalog is lite. Full list: ANALYZTHIS_MCP_CATALOG=full');
     console.log('Restart Claude Code and Claude Desktop to activate.\n');
     return true;
   }
@@ -602,7 +727,9 @@ function writeMcpConfig(target) {
 
 // ── MCP protocol (JSON-RPC 2.0 over stdio) ────────────────────────────────
 
-function startStdioServer() {
+function startStdioServer(catalog) {
+  var catalogMode = resolveCatalog(catalog);
+  var activeTools = listedTools(catalogMode);
   var rl = readline.createInterface({ input: process.stdin, terminal: false });
   var initialized = false;
 
@@ -647,7 +774,7 @@ function startStdioServer() {
         jsonrpc: '2.0',
         id: id,
         result: {
-          tools: TOOLS.map(function(t) {
+          tools: activeTools.map(function(t) {
             return {
               name: t.name,
               description: t.description,
@@ -673,11 +800,17 @@ function startStdioServer() {
         });
       } else {
         var text = result.prompt || result.result || result.command || JSON.stringify(result, null, 2);
+        var receipt = require('./receipt');
+        var wrapped = receipt.wrapPayload(text, {
+          path: 'mcp',
+          persona: result.persona || result.skill || toolName,
+          verdicts: result.verdicts || 0,
+        });
         send({
           jsonrpc: '2.0',
           id: id,
           result: {
-            content: [{ type: 'text', text: String(text) }],
+            content: [{ type: 'text', text: wrapped }],
           },
         });
       }
@@ -711,24 +844,32 @@ function startStdioServer() {
 
   if (process.env.MCP_DEBUG) {
     process.stderr.write('analyzthis_design MCP server v' + VERSION + ' running on stdio\n');
-    process.stderr.write('Tools: ' + TOOLS.length + ' available\n');
+    process.stderr.write('Tools: ' + activeTools.length + ' (' + catalogMode + ' catalog)\n');
   }
 }
 
 // ── Entry point ──
 
+function parseCatalogFlag(args) {
+  var eq = args.filter(function (a) { return a.indexOf('--catalog=') === 0; })[0];
+  if (eq) return eq.split('=').slice(1).join('=');
+  var idx = args.indexOf('--catalog');
+  if (idx !== -1 && args[idx + 1] && args[idx + 1].indexOf('--') !== 0) return args[idx + 1];
+  return null;
+}
+
 function main() {
   var args = process.argv.slice(2);
+  var catalog = parseCatalogFlag(args);
 
   // --configure <target>
   var configureIdx = args.indexOf('--configure');
   if (configureIdx !== -1 && args[configureIdx + 1]) {
-    writeMcpConfig(args[configureIdx + 1]);
+    writeMcpConfig(args[configureIdx + 1], { catalog: catalog });
     return;
   }
 
-  // Default: start stdio server
-  startStdioServer();
+  startStdioServer(catalog);
 }
 
 if (require.main === module) {
@@ -737,6 +878,10 @@ if (require.main === module) {
 
 module.exports = {
   TOOLS: TOOLS,
+  ROUTER_TOOL: ROUTER_TOOL,
+  RECEIPT_TOOL: RECEIPT_TOOL,
+  listedTools: listedTools,
+  resolveCatalog: resolveCatalog,
   handleToolCall: handleToolCall,
   startStdioServer: startStdioServer,
   writeMcpConfig: writeMcpConfig,

package/dist/lib/orchestrator/run.js

@@ -819,6 +819,8 @@ async function runUnchunked(opts = {}) {
         objections_raised: delibResult.metrics.objections_raised,
         objections_resolved: delibResult.metrics.objections_resolved,
         raj_escalations: delibResult.metrics.raj_escalations,
+        verdicts_this_run: 1,
+        tokens_per_verdict: (delibResult.metrics.input_tokens_est || 0) || null,
       },
     },
   });
@@ -834,6 +836,8 @@ async function runUnchunked(opts = {}) {
   if (delibResult.deliberation.raj_escalated) console.log('   Raj escalated: yes');
   console.log(`   Verdict: ${syn.composite.verdict} (${syn.composite.total}/${syn.composite.max_total})`);
   console.log(`   Est. tokens: ${delibResult.metrics.input_tokens_est} in / ${delibResult.metrics.output_tokens_est} out`);
+  const tpvUn = delibResult.metrics.input_tokens_est || 0;
+  if (tpvUn) console.log(`   Tokens per verdict: ${tpvUn} (CLI est. input / 1)`);
   if (costUsd) console.log(`   Est. cost:   $${costUsd.toFixed(4)}`);
   console.log(`   Session: ${session.sessionPath(projectId)}`);
   console.log('\n── Synthesis ──────────────────────────────────────');
@@ -878,6 +882,7 @@ async function run(opts = {}) {
   console.log(`   Cost:    $${(chunkRunState.total_cost || 0).toFixed(4)}`);
   const tokens = chunkRunState.total_tokens || { input: 0, output: 0 };
   console.log(`   Tokens:  ${tokens.input} in / ${tokens.output} out`);
+  if (tokens.input) console.log(`   Tokens per verdict: ${tokens.input} (CLI est. input / 1)`);
   if (syn) {
     console.log(`   Verdict: ${syn.verdict || 'n/a'} (${syn.total || 0}/${syn.max_total || 0})`);
     if (syn.premise_challenge) {

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