analyzthis_design 2.3.0 → 2.4.0

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'],
     },
   },
   {
@@ -285,6 +287,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 +365,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 +376,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 +394,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 +423,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 +481,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 +509,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');
@@ -506,84 +615,86 @@ 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 writeMcpConfig(target) {
-  var serverCmd = 'npx';
-  var serverArgs = ['analyzthis_design', 'mcp'];
+function mergeMcpServer(configPath) {
+  var dir = path.dirname(configPath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  var config = {};
+  if (fs.existsSync(configPath)) {
+    try { config = JSON.parse(fs.readFileSync(configPath, 'utf8')); } catch (e) {}
+  }
+  if (typeof config !== 'object' || config === null || Array.isArray(config)) config = {};
+  config.mcpServers = config.mcpServers || {};
+  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;
+}
+
+function looksLikeProjectCwd() {
+  var cwd = process.cwd();
+  return fs.existsSync(path.join(cwd, 'package.json')) || fs.existsSync(path.join(cwd, '.git'));
+}
+
+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');
-    var cursorDir = path.dirname(cursorConfigPath);
-    if (!fs.existsSync(cursorDir)) fs.mkdirSync(cursorDir, { recursive: true });
-    var cursorConfig = {};
-    if (fs.existsSync(cursorConfigPath)) {
-      try { cursorConfig = JSON.parse(fs.readFileSync(cursorConfigPath, 'utf8')); } catch (e) {}
-    }
-    cursorConfig.mcpServers = cursorConfig.mcpServers || {};
-    cursorConfig.mcpServers['analyzthis_design'] = {
-      command: serverCmd,
-      args: serverArgs,
-    };
-    fs.writeFileSync(cursorConfigPath, JSON.stringify(cursorConfig, null, 2));
+    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;
   }
 
   if (target === 'claude') {
-    var claudeConfigPath;
+    var claudeDesktopPath;
     if (process.platform === 'darwin') {
-      claudeConfigPath = path.join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+      claudeDesktopPath = path.join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
     } else if (process.platform === 'win32') {
-      claudeConfigPath = path.join(home, 'AppData', 'Roaming', 'Claude', 'claude_desktop_config.json');
+      claudeDesktopPath = path.join(home, 'AppData', 'Roaming', 'Claude', 'claude_desktop_config.json');
     } else {
-      claudeConfigPath = path.join(home, '.config', 'Claude', 'claude_desktop_config.json');
+      claudeDesktopPath = path.join(home, '.config', 'Claude', 'claude_desktop_config.json');
     }
-    var claudeDir = path.dirname(claudeConfigPath);
-    if (!fs.existsSync(claudeDir)) fs.mkdirSync(claudeDir, { recursive: true });
-    var claudeConfig = {};
-    if (fs.existsSync(claudeConfigPath)) {
-      try { claudeConfig = JSON.parse(fs.readFileSync(claudeConfigPath, 'utf8')); } catch (e) {}
+    mergeMcpServer(claudeDesktopPath);
+    console.log('Claude Desktop MCP config written to ' + claudeDesktopPath);
+
+    var claudeCodePath = path.join(home, '.claude.json');
+    mergeMcpServer(claudeCodePath);
+    console.log('Claude Code MCP config written to ' + claudeCodePath);
+
+    if (looksLikeProjectCwd()) {
+      var projectMcp = path.join(process.cwd(), '.mcp.json');
+      mergeMcpServer(projectMcp);
+      console.log('Project MCP config written to ' + projectMcp);
     }
-    claudeConfig.mcpServers = claudeConfig.mcpServers || {};
-    claudeConfig.mcpServers['analyzthis_design'] = {
-      command: serverCmd,
-      args: serverArgs,
-    };
-    fs.writeFileSync(claudeConfigPath, JSON.stringify(claudeConfig, null, 2));
-    console.log('Claude Desktop MCP config written to ' + claudeConfigPath);
-    console.log('Restart Claude Desktop to activate.\n');
+
+    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;
   }
 
   if (target === 'windsurf') {
     var windsurfConfigPath = path.join(home, '.codeium', 'windsurf', 'mcp_config.json');
-    var windsurfDir = path.dirname(windsurfConfigPath);
-    if (!fs.existsSync(windsurfDir)) fs.mkdirSync(windsurfDir, { recursive: true });
-    var windsurfConfig = {};
-    if (fs.existsSync(windsurfConfigPath)) {
-      try { windsurfConfig = JSON.parse(fs.readFileSync(windsurfConfigPath, 'utf8')); } catch (e) {}
-    }
-    windsurfConfig.mcpServers = windsurfConfig.mcpServers || {};
-    windsurfConfig.mcpServers['analyzthis_design'] = {
-      command: serverCmd,
-      args: serverArgs,
-    };
-    fs.writeFileSync(windsurfConfigPath, JSON.stringify(windsurfConfig, null, 2));
+    mergeMcpServer(windsurfConfigPath);
     console.log('Windsurf MCP config written to ' + windsurfConfigPath);
     console.log('Restart Windsurf to activate.\n');
     return true;
@@ -593,8 +704,8 @@ function writeMcpConfig(target) {
   console.log(JSON.stringify({
     mcpServers: {
       'analyzthis_design': {
-        command: serverCmd,
-        args: serverArgs,
+        command: 'npx',
+        args: ['analyzthis_design', 'mcp'],
       }
     }
   }, null, 2));
@@ -604,7 +715,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;
 
@@ -649,7 +762,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,
@@ -675,11 +788,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 }],
           },
         });
       }
@@ -713,24 +832,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) {
@@ -739,6 +866,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/session.js

@@ -95,6 +95,9 @@ function defaultState(projectId) {
       objections_raised: 0,
       objections_resolved: 0,
       raj_escalations: 0,
+      host_turns: [],
+      verdicts_this_run: 0,
+      tokens_per_verdict: null,
     },
   };
 }
@@ -147,7 +150,11 @@ function reset({ project, all = false } = {}) {
 function update({ project, patch = {} } = {}) {
   const projectId = project || getProjectId();
   const existing = show({ project: projectId }) || defaultState(projectId);
-  const merged = { ...existing, ...patch, updated_at: new Date().toISOString() };
+  const patchCopy = { ...patch };
+  if (patchCopy.metrics && existing.metrics) {
+    patchCopy.metrics = { ...existing.metrics, ...patchCopy.metrics };
+  }
+  const merged = { ...existing, ...patchCopy, updated_at: new Date().toISOString() };
   const dir = sessionDir(projectId);
   fs.mkdirSync(dir, { recursive: true });
   fs.writeFileSync(sessionPath(projectId), JSON.stringify(merged, null, 2));
@@ -181,6 +188,30 @@ function markAccepted({ project, persona, accepted = true } = {}) {
   return { updated: true, state: merged };
 }
 
+/**
+ * Append one inferred host (slash/MCP) turn. Caps the log. Recomputes tokens_per_verdict.
+ */
+function logHostTurn({ project, path: turnPath, persona, inferred_in, verdicts = 0 } = {}) {
+  const projectId = project || getProjectId();
+  const existing = show({ project: projectId }) || defaultState(projectId);
+  const metrics = { ...(existing.metrics || {}) };
+  const turns = Array.isArray(metrics.host_turns) ? metrics.host_turns.slice() : [];
+  turns.push({
+    at: new Date().toISOString(),
+    path: turnPath || 'mcp',
+    persona: persona || '',
+    inferred_in: Number(inferred_in) || 0,
+  });
+  const cap = 40;
+  metrics.host_turns = turns.length > cap ? turns.slice(turns.length - cap) : turns;
+  if (verdicts) metrics.verdicts_this_run = (metrics.verdicts_this_run || 0) + verdicts;
+  const host = metrics.host_turns.reduce((sum, t) => sum + (t.inferred_in || 0), 0);
+  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 } });
+}
+
 module.exports = {
-  getProjectId, sessionPath, sessionDir, init, show, reset, update, listProjects, markAccepted, SESSIONS_ROOT,
+  getProjectId, sessionPath, sessionDir, init, show, reset, update, listProjects, markAccepted, logHostTurn, SESSIONS_ROOT,
 };

package/dist/skills/anuj/SKILL.md

@@ -21,6 +21,13 @@ You are Anuj (alias: Dev). 6 years as a domain analyst in high-volume operations
 
 **Assess-only:** if the user asked to assess/propose/critique rather than build/implement/ship, stop at the concept — do not edit code.
 
+
+## Lite output (default)
+
+Verdict or one moment. Top three fixes (or one delight). One evidence line.
+Use the full output schema below only if the user says expand.
+You cannot know host tokens. Do not invent a dollar figure.
+
 ## Non-negotiables
 
 - **Density never flattens the information hierarchy.** Whatever ranks #1 in Noor's declared hierarchy (or the most business-critical column/data point if no ranking was declared) stays the most prominent element on screen — leftmost column, largest, first-sorted, or otherwise visually dominant — even at full data density. "Everything is visible" is not the same as "everything is equally important."