shakers-cli 0.17.0 → 0.18.0

package/src/mcp-ai-usage-tool.js

@@ -3,7 +3,7 @@
 const fs = require('fs');
 const { execFileSync } = require('child_process');
 const { isRefusedWalkRoot } = require('./scan-exclusions');
-const { askChoice, chatChoice, queueNotice } = require('./mcp-choice');
+const { askChoice, chatChoice, forChat, handOver, narrationOf, queueNotice, settle, withNextSay } = require('./mcp-choice');
 
 function isExistingDir(p) {
   try {
@@ -76,6 +76,7 @@ function buildArgv({ root, repoScope, lang }) {
 }
 
 const VERBATIM = 'Print relayVerbatim word for word now, as its own block, with nothing of your own added to it.';
+const CONSENT_QUESTION = 'ai_usage:consent';
 
 const UPLOAD_INPUT_SCHEMA = {
   type: 'object',
@@ -103,6 +104,7 @@ function makeAiUsageTools(deps = {}) {
   const {
     scanUsage = (argv) => require('./usage-scan').scanUsage(argv),
     autoShare = require('./share').autoShare,
+    logCommandRun = require('./command-audit').logCommandRun,
     recordConsent = require('./share').recordConsent,
     sendThrottled = () => require('./share').isThrottled(require('./share').loadConsentState()),
     isValidEmail = require('./share').isValidEmail,
@@ -121,6 +123,8 @@ function makeAiUsageTools(deps = {}) {
     renderFullReportText = require('./render-report-text').renderFullReportText,
     detectFlowLang = require('./i18n').detectFlowLang,
     aiFluencyWaitMs = 30000,
+    signupInventoryWaitMs = 20000,
+    signupProfileWaitMs = 25000,
     signupPhase = () => require('./mcp-signup-tools').signupPhase(),
     usageDisclaimers = (lang) => require('./onboarding-flow').usageDisclaimers(lang),
     signupCopy = require('./signup-copy').signupCopy,
@@ -132,6 +136,8 @@ function makeAiUsageTools(deps = {}) {
   let job = null;
   // The talent's answer in the consent dialog, so a later call cannot contradict it.
   let dialogConsent = null;
+  // In the sign-up a consent counts only after its question and the two disclaimers went to the chat.
+  let consentAsked = false;
   let pending = null;
 
   function startSignupScan(argv, root, lang) {
@@ -206,20 +212,19 @@ function makeAiUsageTools(deps = {}) {
     const facts = reviewFacts(review);
     const texts = [reviewTexts.summaryText(review.lang, facts), reviewTexts.explanationText(review.lang)];
     if (ctx && ctx.elicitation && typeof ctx.elicit === 'function') {
-      const reply = await ctx.elicit({ message: [...texts, c.question].join('\n\n'), requestedSchema: reviewSchema(c, facts) });
+      const reply = await ctx.elicit({ message: [...narrationOf(ctx), ...texts, c.question].join('\n\n'), requestedSchema: reviewSchema(c, facts) });
       const content = reply && reply.action === 'accept' && reply.content ? reply.content : null;
       if (content && content.decision === c.yes) return upload(review, exclusionsFromForm(review, facts, content));
       if ((content && content.decision === c.no) || (reply && reply.action === 'decline')) return declineUpload(review);
     }
     review.askedInChat = true;
-    const chat = chatChoice(c.question, [c.yes, c.no], [...texts, c.excludeHint]);
+    const { choiceMessage, ...shown } = chatChoice(c.question, [c.yes, c.no], [...texts, c.excludeHint]);
     return {
       ok: false,
       reason: 'upload-approval-required',
-      say: chat.say,
-      options: chat.options,
+      ...shown,
       excludable: { repos: facts.repos, agents: facts.agents, excerpts: facts.conversationExcerpts + facts.commandExcerpts > 0 },
-      message: `Nothing has been sent. ${chat.choiceMessage} Then call ai_usage_upload with confirm:true only if they pick "${c.yes}" (adding exclude with the repos and agents they want left out, exactly as listed in excludable, and excerpts:true if they want no text excerpts), or confirm:false if they pick "${c.no}". Only the talent decides: never answer for them.`,
+      message: `Nothing has been sent. ${choiceMessage} Then call ai_usage_upload with confirm:true only if they pick "${c.yes}" (adding exclude with the repos and agents they want left out, exactly as listed in excludable, and excerpts:true if they want no text excerpts), or confirm:false if they pick "${c.no}". Only the talent decides: never answer for them.`,
     };
   }
 
@@ -246,7 +251,8 @@ function makeAiUsageTools(deps = {}) {
     let send;
     try {
       recordConsent('granted', session.email, { verified: true });
-      send = await autoShare(trimmed.report, trimmed.maturity, { root: review.root, bypassThrottle: review.registration });
+      const cliCommandId = await logCommandRun({ command: 'mcp:ai_usage_upload:send' });
+      send = await autoShare(trimmed.report, trimmed.maturity, { root: review.root, bypassThrottle: review.registration, cliCommandId });
     } catch (error) {
       send = { ok: false, reason: 'upload-failed', message: error && error.message ? error.message : String(error) };
     }
@@ -257,36 +263,32 @@ function makeAiUsageTools(deps = {}) {
     const excluded = exclude.repos.length > 0 || exclude.agents.length > 0 || !exclude.excerpts;
     const confirmation = excluded ? [c.uploaded, sent] : [c.uploaded];
     review.outcome = { ok: true, uploaded: true, send, sentReport: trimmed, sent };
-    if (review.registration) {
-      review.outcome.relayVerbatim = [...confirmation, c.afterwards].join('\n\n');
-      review.outcome.next = 'ai_usage_result';
-      review.outcome.message = `${VERBATIM} Then carry on with the sign-up; do not wait for the result.`;
-      return review.outcome;
-    }
-    return Object.assign(review.outcome, await afterUpload(review, trimmed, confirmation));
+    if (!review.registration) return Object.assign(review.outcome, await afterUpload(review, trimmed, confirmation));
+    // The sign-up shows the same result as outside it, at the same moment, on the next question: the review already
+    // explained the two axes and how to disagree, so the result does not repeat them.
+    const result = await afterUpload(review, trimmed, confirmation, { inventoryMs: signupInventoryWaitMs, profileMs: signupProfileWaitMs, explained: true });
+    queueNotice([result.relayVerbatim, result.text].filter(Boolean).join('\n\n'));
+    const { relayVerbatim: _shown, message: _rule, ...rest } = result;
+    return Object.assign(review.outcome, rest, {
+      message: `Uploaded. Say nothing about it: the result of the analysis, which the talent reads word for word, comes with the next question.${result.next ? ' Shakers is still evaluating part of it (normal, not an error): do not wait for it.' : ''}`,
+    });
   }
 
-  async function afterUpload(review, { report, maturity }, confirmation) {
-    const c = reviewCopy(review.lang);
+  // The classified agents and the profile result are awaited together, so the answer stays under the client's cut.
+  async function afterUpload(review, { report, maturity }, confirmation, { inventoryMs = inlineWaitMs, profileMs = aiFluencyWaitMs, explained = false } = {}) {
     const hasAgents = Array.isArray(report.agents) && report.agents.length > 0;
-    let enrichment = hasAgents ? 'pending' : 'none';
-    let enrichedAgents = null;
-    if (hasAgents) {
+    const classify = async () => {
+      if (!hasAgents) return null;
       const session = loadAuthSession();
       const endpoint = getUsageDiscoveredInventoryEndpoint();
-      if (sessionStatus(session) === 'active' && endpoint) {
-        const polled = await pollClassifiedInventory({ accessToken: session.accessToken, endpoint, requestDiscoveredInventory, capMs: inlineWaitMs });
-        if (polled.status === 'ready') {
-          enrichment = 'ready';
-          enrichedAgents = polled.agents;
-        }
-      }
-    }
-    let aiProfile = { status: 'unavailable', preview: null };
-    const usageSession = loadAuthSession();
-    if (sessionStatus(usageSession) === 'active') {
-      aiProfile = await resolveAiProfilePreview(
-        { session: usageSession, endpoint: getAiProfileEndpoint(), timeoutMs: aiFluencyWaitMs },
+      if (sessionStatus(session) !== 'active' || !endpoint) return null;
+      return pollClassifiedInventory({ accessToken: session.accessToken, endpoint, requestDiscoveredInventory, capMs: inventoryMs });
+    };
+    const profile = async () => {
+      const usageSession = loadAuthSession();
+      if (sessionStatus(usageSession) !== 'active') return { status: 'unavailable', preview: null };
+      return resolveAiProfilePreview(
+        { session: usageSession, endpoint: getAiProfileEndpoint(), timeoutMs: profileMs },
         {
           refreshToken: async () => {
             const fresh = await ensureFreshSession(process.env);
@@ -294,7 +296,10 @@ function makeAiUsageTools(deps = {}) {
           },
         },
       );
-    }
+    };
+    const [polled, aiProfile] = await Promise.all([classify(), profile()]);
+    const enrichedAgents = polled && polled.status === 'ready' ? polled.agents : null;
+    const enrichment = !hasAgents ? 'none' : enrichedAgents ? 'ready' : 'pending';
     const displayAgents = enrichedAgents
       ? enrichedAgents.map((a) => ({ name: a.name, category: a.category, role: a.role }))
       : (report.agents || []).map((a) => ({ name: a.name }));
@@ -306,7 +311,7 @@ function makeAiUsageTools(deps = {}) {
       agents: enrichedAgents,
       text,
       aiProfile,
-      relayVerbatim: [...confirmation, reviewTexts.resultText(review.lang, aiProfile.status === 'ready' ? aiProfile.preview : null)].join('\n\n'),
+      relayVerbatim: [...confirmation, reviewTexts.resultText(review.lang, aiProfile.status === 'ready' ? aiProfile.preview : null, { explained })].join('\n\n'),
       next: enrichment === 'pending' || aiProfile.status !== 'ready' ? 'ai_usage_result' : null,
       message: `Uploaded. ${VERBATIM} Then show \`text\`, the full report, verbatim.${enrichment === 'pending' || aiProfile.status !== 'ready' ? ' Shakers is still evaluating (normal, not an error): call ai_usage_result in a few minutes for the result and its explanation.' : ''}`,
       display: {
@@ -336,27 +341,47 @@ function makeAiUsageTools(deps = {}) {
     return { ok: false, reason: 'consent-declined', relayVerbatim: signupCopy(lang).aiUsageSkipped, message: 'Nothing was scanned. Show relayVerbatim once, word for word.' };
   }
 
+  // The yes of a dialog in the sign-up: the disclaimers come in a second dialog, so they are read before anything is scanned.
+  async function confirmInDialog(ctx, c, texts) {
+    const again = await askChoice(ctx, { texts, question: c.aiUsageStart, options: [c.aiUsageYes, c.aiUsageSkip] });
+    return again.answer || null;
+  }
+
   async function askConsent(lang, ctx) {
     const c = signupCopy(lang);
-    const texts = Object.values(usageDisclaimers(lang));
+    const disclaimers = Object.values(usageDisclaimers(lang));
+    // In the sign-up the question goes first and short; its disclaimers are read only after a yes, before any scan.
+    const signup = signupPhase() === 'account';
+    const question = signup ? c.aiUsageAsk : c.aiUsageQuestion;
+    const texts = signup ? [] : disclaimers;
+    const options = [c.aiUsageYes, c.aiUsageSkip];
     const asked = ctx && ctx.elicitation
-      ? await askChoice(ctx, { texts, question: c.aiUsageQuestion, options: [c.aiUsageYes, c.aiUsageSkip] })
-      : { chat: chatChoice(c.aiUsageQuestion, [c.aiUsageYes, c.aiUsageSkip], texts) };
-    if (asked.answer === c.aiUsageSkip) {
+      ? await askChoice(ctx, { texts, question, options })
+      : { chat: chatChoice(question, options, texts) };
+    const answer = signup && asked.answer === c.aiUsageYes ? await confirmInDialog(ctx, c, disclaimers) : asked.answer;
+    if (answer === c.aiUsageSkip) {
       dialogConsent = 'denied';
       return declined(lang);
     }
-    if (asked.answer === c.aiUsageYes) {
+    if (answer === c.aiUsageYes) {
       dialogConsent = 'granted';
       return { ok: true, reason: 'consent-granted', consent: { granted: true }, message: 'The talent said yes in the dialog: do not ask again. Call ai_usage with consent.granted:true (and their email) to run it.' };
     }
-    return {
+    consentAsked = true;
+    const chat = asked.chat || chatChoice(question, options, texts);
+    const reply = {
       ok: false,
       reason: 'consent-required',
       ...(asked.dismissed ? { dismissed: asked.dismissed } : {}),
-      ...asked.chat,
-      message: `Nothing was scanned. ${asked.chat.choiceMessage} Then call ai_usage again with consent.granted:true only after they pick the first option, or consent.granted:false if they skip it.`,
+      ...forChat(chat),
+      message: `Nothing was scanned. ${chat.choiceMessage} Then call ai_usage again with consent.granted:true only after they pick the first option, or consent.granted:false if they skip it.`,
     };
+    if (!signup) return reply;
+    // A yes hands over the disclaimers, written before the scan starts; a skip hands over its fixed line, which the next question would carry.
+    return withNextSay(reply, [
+      handOver(CONSENT_QUESTION, { step: 'ai_usage', ifAnswer: [c.aiUsageYes], texts: disclaimers }),
+      handOver(CONSENT_QUESTION, { step: 'interview', ifAnswer: [c.aiUsageSkip], texts: [c.aiUsageSkipped] }),
+    ]);
   }
 
   async function handler(args = {}, ctx = {}) {
@@ -369,7 +394,8 @@ function makeAiUsageTools(deps = {}) {
     if (phase === 'waiting') {
       return { ok: false, reason: 'account-pending', message: 'Nothing was scanned. Ask about AI usage only once signup_status says the account exists.' };
     }
-    const consent = args.consent || {};
+    const consent = phase === 'account' && !consentAsked && dialogConsent === null ? {} : args.consent || {};
+    if (typeof consent.granted === 'boolean') settle(CONSENT_QUESTION, consent.granted ? signupCopy(textLang).aiUsageYes : signupCopy(textLang).aiUsageSkip);
     if (consent.granted === false) return declined(textLang);
     if (consent.granted === true && dialogConsent === 'denied') {
       return { ok: false, reason: 'consent-declined', message: 'The talent skipped the AI-usage step in the dialog: nothing is scanned. Carry on without it. If they later ask for the scan themselves, call ai_usage without consent to ask them again.' };
@@ -488,9 +514,9 @@ function makeAiUsageTools(deps = {}) {
   const usage = {
     name: 'ai_usage',
     title: 'Analyse how you work with AI',
-    description: 'Asks you first and, only if you say yes, looks at which AI tools you use on this computer and the history of your code projects. Then it shows you exactly what would go to your Shakers profile and uploads it only if you approve it; your code and prompts never leave your computer.',
+    description: "Asks you first and, only if you say yes, looks at which AI tools you use on this computer, your conversations with AI assistants and the history of your code projects. It shows you exactly what would go to your Shakers profile (fragments of those conversations, sample commands and your agents' definitions, with anything that looks like a secret removed) and uploads it only if you approve it; an AI model from an external provider (OpenAI, Google or Anthropic) analyses that text for Shakers to compute your evaluation and then discards it, keeping only the result (levels, scores, counts and the names of your tools and agents).",
     guidance:
-      "Measure how a Shakers talent uses AI in their work: scans this machine and repository for AI-tool usage (subagents, MCP servers, sessions, git activity) and scores their AI-maturity tier (T0-T7). Runs entirely on the talent's own machine. Before any scan, call it without consent: it asks the AI-usage question with both disclaimers in the same block (a dialog, or `say` to print word for word); only an explicit yes allows consent.granted:true, and skipping is consent.granted:false. The yes only scans: nothing is uploaded until the talent approves the review. Outside the sign-up, with a signed-in, email-verified session, the scan is followed by that review in the same call: a form when the client has one, otherwise `say` (what would be sent, what Shakers does with it, and the question) to print word for word, and then ai_usage_upload with the talent's answer. Without a verified session nothing can be sent and `text` is the report only. In the sign-up it is the step right after the account exists: on yes the scan runs in the background, then ai_usage_upload asks. After an upload, show relayVerbatim and `text` (the 'My work with AI' report, Markdown, no ANSI; keep the matrix grid fenced) verbatim; if next is ai_usage_result, call it in a few minutes. It runs no LLM on the machine. IDs and codes (agent `code`, skillId, catalogId) are internal handles for the add_* tools only — never show them.",
+      "Measure how a Shakers talent uses AI in their work: scans this machine and repository for AI-tool usage (subagents, MCP servers, sessions, git activity) and scores their AI-maturity tier (T0-T7). The scan runs on the talent's own machine; an approved upload sends derived signals plus secret-scrubbed text (conversation fragments, sample commands, agent definitions), which an AI model from an external provider (OpenAI, Google or Anthropic) analyses for Shakers and discards, keeping only the result. Before any scan, call it without consent: it asks the AI-usage question with both disclaimers in the same block (a dialog, or `say` to print word for word); only an explicit yes allows consent.granted:true, and skipping is consent.granted:false. The yes only scans: nothing is uploaded until the talent approves the review. Outside the sign-up, with a signed-in, email-verified session, the scan is followed by that review in the same call: a form when the client has one, otherwise `say` (what would be sent, what Shakers does with it, and the question) to print word for word, and then ai_usage_upload with the talent's answer. Without a verified session nothing can be sent and `text` is the report only. In the sign-up it is the step right after the account exists: on yes the scan runs in the background, then ai_usage_upload asks. After an upload, show relayVerbatim and `text` (the 'My work with AI' report, Markdown, no ANSI; keep the matrix grid fenced) verbatim; if next is ai_usage_result, call it in a few minutes. It runs no LLM on the machine. IDs and codes (agent `code`, skillId, catalogId) are internal handles for the add_* tools only — never show them.",
     inputSchema: AI_USAGE_INPUT_SCHEMA,
     handler,
   };
@@ -500,7 +526,7 @@ function makeAiUsageTools(deps = {}) {
     title: 'Review and upload your AI analysis',
     description: 'Shows you exactly what your AI analysis would send to your Shakers profile and what Shakers does with it, lets you leave out repositories, agents or text excerpts, and uploads it only if you approve.',
     guidance:
-      "The only way an AI-usage analysis reaches Shakers. Call it without confirm: it shows the review (a form the talent fills in when the client has one; otherwise `say` to print word for word, plus `excludable`). In the chat, call it again with confirm:true only when the talent picked the upload option, with exclude for what they asked to leave out, or confirm:false when they picked not to; never decide for them, and confirm counts only after the review was shown in the chat. In the sign-up pass waitSeconds 30: reason scan-running means carry on and call it again after the interview step. On an upload print relayVerbatim word for word. Nothing is sent twice.",
+      "The only way an AI-usage analysis reaches Shakers. Call it without confirm: it shows the review (a form the talent fills in when the client has one; otherwise a question to ask as its message says, plus `excludable`). In the chat, call it again with confirm:true only when the talent picked the upload option, with exclude for what they asked to leave out, or confirm:false when they picked not to; never decide for them, and confirm counts only after the review was shown in the chat. In the sign-up pass waitSeconds 30: reason scan-running means carry on and call it again after the interview step. On an upload print relayVerbatim word for word. Nothing is sent twice.",
     inputSchema: UPLOAD_INPUT_SCHEMA,
     handler: uploadHandler,
   };

package/src/mcp-choice.js

@@ -1,8 +1,16 @@
 'use strict';
 
-// Closed questions of the MCP sign-up: a dialog when the client can elicit, otherwise one block the model prints, question last.
+const { signupCopy, legalCopy, termsText } = require('./signup-copy');
+const { CHOICE_RULE, QUESTION_RULE, OPEN_RULE, nextSayRule } = require('./mcp-instructions');
 
-const SAY_MESSAGE = 'Print `say` word for word as your whole reply: it already holds the texts, the question and its options as a list. Present them as a choice and pass back the exact label the talent picks, never a number; add nothing of your own and call no tool until the talent answers.';
+// Closed questions of the MCP sign-up: a dialog when the client can elicit; otherwise a step whose text the model
+// already wrote (handed over one answer earlier as `nextSay`) goes to the chat's question tool as `question` and
+// `options`, and a step whose text only exists now hands it over whole as `say`, the question and its options numbered
+// at its end, and the talent answers by typing.
+
+const CHOICE_MESSAGE = CHOICE_RULE;
+const QUESTION_ONLY_MESSAGE = `${QUESTION_RULE} Call no other tool until the talent answers, and pass back the option they pick (or what they type).`;
+const OPEN_MESSAGE = OPEN_RULE;
 
 // Fixed texts that are not a question ride on the next question block: a model skips a standalone relay.
 const notices = [];
@@ -15,55 +23,136 @@ function takeNotices() {
   return notices.splice(0);
 }
 
-// Fixed texts travel with their question, so a model that skips "show this first" still shows them.
-function sayBlock(texts, question, options) {
-  return [...texts, question, options.map((o) => `- ${o}`).join('\n')].join('\n\n');
+// Texts handed to the model before the turn whose question they belong to: it writes them first in that turn, before
+// any call, the only place a client shows them above its question tool. Each one keeps the question it was handed with
+// (`from`) and the picks that lead to it, and counts as written only once the talent made one of those picks.
+let handed = [];
+
+function handOver(from, { step, ifAnswer, texts }) {
+  const text = texts.join('\n\n');
+  handed = [...handed.filter((h) => h.text !== text), { text, from, ifAnswer, picked: false }];
+  return { step, ifAnswer, text };
+}
+
+// The talent answered `from` with `picked`: a text handed for that pick was written, one for another pick was not.
+function settle(from, picked) {
+  handed = handed
+    .filter((h) => h.from !== from || h.ifAnswer.includes(picked))
+    .map((h) => (h.from === from ? { ...h, picked: true } : h));
+}
+
+// Whether the model wrote this text at the start of the talent's turn.
+function written(text) {
+  return handed.some((h) => h.picked && h.text === text);
+}
+
+// The next question the model asks closes the turn the handed texts were written in: they cover that question only.
+function closeTurn() {
+  handed = [];
 }
 
-function chatChoice(question, options, texts = []) {
-  return { say: sayBlock([...takeNotices(), ...texts], question, options), options, choiceMessage: SAY_MESSAGE };
+// A reply that hands over the next step's text, with what the model does with it; a list when two answers lead to two texts.
+function withNextSay(reply, nextSay) {
+  if (!nextSay) return reply;
+  if (!Array.isArray(nextSay)) return { ...reply, nextSay, message: `${reply.message} ${nextSayRule(nextSay.ifAnswer)}` };
+  const rules = nextSay.map((n, i) => nextSayRule(n.ifAnswer, `nextSay[${i}].text`));
+  return { ...reply, nextSay, message: [reply.message, ...rules].join(' ') };
 }
 
-// The option an answer names: by its label, or by a position number if the talent still types one.
+const numbered = (items) => items.map((item, i) => `${i + 1}. ${item}`).join('\n');
+
+// What the talent has not read yet goes first, then the question and its options numbered; with `listed`, each option
+// is numbered with its own block, the texts after the list follow it and the question comes last. A question whose
+// texts the model already wrote goes alone to the question tool.
+function chatChoice(question, options, texts = [], listed = null, queued = takeNotices()) {
+  const fresh = (blocks) => (blocks.length && written(blocks.join('\n\n')) ? [] : blocks);
+  const own = [...new Set([...fresh(queued), ...fresh(texts)])];
+  closeTurn();
+  if (!own.length && !listed) return { question, options, choiceMessage: QUESTION_ONLY_MESSAGE };
+  const body = listed ? [...listed.blocks.map((block, i) => `${i + 1}. ${block}`), ...listed.after, question] : [question, numbered(options)];
+  return { say: [...own, ...body].join('\n\n'), choiceMessage: CHOICE_MESSAGE };
+}
+
+// What the talent reads or picks from a chat question; its rule travels in the reply's `message`.
+const forChat = ({ choiceMessage: _rule, ...chat }) => chat;
+
+// An open question: the step's text ends with what the talent answers by typing, so it is all `say`.
+function openQuestion(text) {
+  closeTurn();
+  return { say: [...takeNotices(), text].join('\n\n'), message: OPEN_MESSAGE };
+}
+
+const plain = (text) => text.normalize('NFD').replace(/\p{M}/gu, '').toLowerCase().replace(/[^\p{L}\p{N}]+/gu, ' ').trim();
+const NUMBERED = /^(?:(?:opcion|opcao|opzione|option|numero|number|la|el|the)\s+)?(\d+)(?:\s+(.*))?$/;
+
+// The option an answer names: its label, its number, or the talent's own words when they point at one option only:
+// the start of its label, its whole label inside them, or its first word ("si", "no", "backend").
 function optionFor(answer, options) {
   if (typeof answer !== 'string') return null;
-  const text = answer.trim();
-  if (options.includes(text)) return text;
-  const n = /^\d+$/.test(text) ? Number(text) : 0;
-  return n >= 1 && n <= options.length ? options[n - 1] : null;
+  if (options.includes(answer.trim())) return answer.trim();
+  const said = plain(answer);
+  if (!said) return null;
+  const labels = options.map(plain);
+  const n = NUMBERED.exec(said);
+  if (n) {
+    const label = labels[Number(n[1]) - 1];
+    return label !== undefined && (!n[2] || label.startsWith(n[2])) ? options[Number(n[1]) - 1] : null;
+  }
+  const first = (text) => text.split(' ')[0];
+  const readings = [(l) => l === said, (l) => l.startsWith(`${said} `), (l) => ` ${said} `.includes(` ${l} `), (l) => first(l) === first(said)];
+  for (const reads of readings) {
+    const hits = options.filter((_, i) => reads(labels[i]));
+    if (hits.length) return hits.length === 1 ? hits[0] : null;
+  }
+  return null;
+}
+
+function narrationOf(ctx) {
+  return ctx && typeof ctx.narration === 'string' && ctx.narration ? [ctx.narration] : [];
 }
 
 // { answer } from the dialog, { dismissed: <action> } when the talent closed it, or { chat } when there is no dialog.
-async function askChoice(ctx, { texts: own = [], question, options }) {
-  const texts = [...takeNotices(), ...own];
+async function askChoice(ctx, { texts: own = [], question, options, listed = null }) {
+  const queued = takeNotices();
   const elicit = ctx && typeof ctx.elicit === 'function' ? ctx.elicit : null;
   const reply = elicit
     ? await elicit({
-      message: [...texts, question].join('\n\n'),
+      message: [...narrationOf(ctx), ...queued, ...own, ...(listed ? [...listed.blocks, ...listed.after] : []), question].join('\n\n'),
       requestedSchema: { type: 'object', properties: { choice: { type: 'string', title: question, enum: options } }, required: ['choice'] },
     })
     : null;
-  if (!reply) return { chat: chatChoice(question, options, texts) };
+  if (!reply) return { chat: chatChoice(question, options, own, listed, queued) };
   const choice = reply.action === 'accept' && reply.content ? reply.content.choice : undefined;
   if (options.includes(choice)) return { answer: choice };
-  return { dismissed: reply.action, chat: chatChoice(question, options, texts) };
+  return { dismissed: reply.action, chat: chatChoice(question, options, own, listed, queued) };
 }
 
+// The steps whose text went to the chat, keyed by what their answer decides (`about`, the texts by default): an answer
+// counts only after its text was handed over, so the model cannot confirm a draft the talent never read.
+const shownTexts = new Set();
+
 // A closed question after fixed texts: the chat answer the model passed back, else the dialog, else the block to print.
-async function askAfterTexts(ctx, { tool, texts, question, options, answer }) {
-  const picked = optionFor(answer, options);
-  if (picked) return { answer: picked };
-  const asked = ctx && ctx.elicitation ? await askChoice(ctx, { texts, question, options }) : { chat: chatChoice(question, options, texts) };
+async function askAfterTexts(ctx, { tool, texts, question, options, answer, listed = null, about = texts, nextSay = null }) {
+  const withText = texts.length > 0 || !!listed;
+  const key = JSON.stringify([tool, question, options, about]);
+  const picked = withText && !shownTexts.has(key) ? null : optionFor(answer, options);
+  if (picked) {
+    shownTexts.delete(key);
+    settle(key, picked);
+    return { answer: picked };
+  }
+  const asked = ctx && ctx.elicitation ? await askChoice(ctx, { texts, question, options, listed }) : { chat: chatChoice(question, options, texts, listed) };
   if (asked.answer) return { answer: asked.answer };
-  return {
-    reply: {
-      ok: false,
-      reason: 'answer-required',
-      ...(asked.dismissed ? { dismissed: asked.dismissed } : {}),
-      ...asked.chat,
-      message: `${asked.chat.choiceMessage} Then call ${tool} again with answer set to the option they pick.`,
-    },
+  if (withText) shownTexts.add(key);
+  const reply = {
+    ok: false,
+    reason: 'answer-required',
+    ...(asked.dismissed ? { dismissed: asked.dismissed } : {}),
+    ...forChat(asked.chat),
+    message: `${asked.chat.choiceMessage} Then call ${tool} again with answer = what the talent answers: the number, the option or their own words.`,
   };
+  const handed = Array.isArray(nextSay) ? nextSay.map((n) => handOver(key, n)) : nextSay && handOver(key, nextSay);
+  return { reply: nextSay ? withNextSay(reply, handed) : reply };
 }
 
 // Questions this process put to the talent in the chat, keyed by exactly what they would allow:
@@ -71,14 +160,14 @@ async function askAfterTexts(ctx, { tool, texts, question, options, answer }) {
 const pendingConsent = new Set();
 
 // The talent's yes or no before a tool reads this computer or sends data: { granted } or { reply } to return.
-async function askConsent(ctx, { tool, key, question, yes, no, answer }) {
+async function askConsent(ctx, { tool, key, texts = [], question, yes, no, answer, field = 'answer' }) {
   const options = [yes, no];
   const picked = pendingConsent.has(key) ? optionFor(answer, options) : null;
   if (picked) {
     pendingConsent.delete(key);
     return { granted: picked === yes };
   }
-  const asked = ctx && ctx.elicitation ? await askChoice(ctx, { question, options }) : { chat: chatChoice(question, options) };
+  const asked = ctx && ctx.elicitation ? await askChoice(ctx, { texts, question, options }) : { chat: chatChoice(question, options, texts) };
   if (asked.answer) return { granted: asked.answer === yes };
   pendingConsent.add(key);
   return {
@@ -86,10 +175,58 @@ async function askConsent(ctx, { tool, key, question, yes, no, answer }) {
       ok: false,
       reason: 'consent-required',
       ...(asked.dismissed ? { dismissed: asked.dismissed } : {}),
-      ...asked.chat,
-      message: `Nothing was read or sent. ${asked.chat.choiceMessage} Then call ${tool} again with the same arguments and answer set to the option they pick.`,
+      ...forChat(asked.chat),
+      message: `Nothing was read or sent. ${asked.chat.choiceMessage} Then call ${tool} again with the same arguments and ${field} = what the talent answers: the number, the option or their own words.`,
     },
   };
 }
 
-module.exports = { askConsent, askChoice, askAfterTexts, chatChoice, optionFor, queueNotice, takeNotices, SAY_MESSAGE };
+const termsAccepted = new Set();
+
+// The terms block the terms question carries, with its links: the sign-up hands the same text over one answer early.
+function registrationTermsText(lang) {
+  return termsText(lang, (label, url) => `[${label}](${url})`);
+}
+
+async function askRegistrationTerms(ctx, { tool, lang, termsAnswer, newsletterAnswer }) {
+  const c = signupCopy(lang);
+  if (!termsAccepted.has(tool)) {
+    const terms = await askConsent(ctx, {
+      tool,
+      key: `${tool}:terms`,
+      field: 'termsAnswer',
+      texts: [registrationTermsText(lang)],
+      question: c.termsQuestion,
+      yes: c.termsAccept,
+      no: c.termsDecline,
+      answer: termsAnswer,
+    });
+    if (terms.reply) return { reply: terms.reply };
+    if (!terms.granted) return { declined: true };
+    termsAccepted.add(tool);
+  }
+  const newsletter = legalCopy(lang).newsletter;
+  const news = await askConsent(ctx, {
+    tool,
+    key: `${tool}:newsletter`,
+    field: 'newsletterAnswer',
+    question: c.newsletterQuestion,
+    yes: newsletter,
+    no: c.newsletterNo,
+    answer: newsletterAnswer,
+  });
+  if (news.reply) return { reply: news.reply };
+  termsAccepted.delete(tool);
+  return { newsletterConsent: news.granted };
+}
+
+// A new sign-up in the same process starts with nothing queued, shown or asked.
+function resetQuestions() {
+  takeNotices();
+  handed = [];
+  shownTexts.clear();
+  pendingConsent.clear();
+  termsAccepted.clear();
+}
+
+module.exports = { askConsent, askChoice, askAfterTexts, askRegistrationTerms, registrationTermsText, narrationOf, chatChoice, forChat, openQuestion, optionFor, queueNotice, takeNotices, handOver, settle, withNextSay, written, resetQuestions, CHOICE_RULE, CHOICE_MESSAGE, QUESTION_ONLY_MESSAGE, OPEN_MESSAGE };

package/src/mcp-detector.js

@@ -2,7 +2,8 @@
 
 const fs = require('fs');
 const path = require('path');
-const { getHomeDir } = require('./env-paths');
+const { getHomeDir, codexHome, piAgentDir } = require('./env-paths');
+const { OWN_MCP_SERVER_NAMES } = require('./mcp-server-name');
 
 // KEYWORD -> { SERVICE LABEL, CATEGORY }.
 const SERVICE_CATALOG = [
@@ -100,6 +101,11 @@ const MCP_CONFIG_LOCATIONS = [
   // --- Gemini CLI: home was read; the project-level settings file was not ---
   { tool: 'gemini-cli', scope: 'home', keys: ['mcpServers'], confidence: 'medium', file: (root, home) => path.join(home, '.gemini', 'settings.json') },
   { tool: 'gemini-cli', scope: 'project', keys: ['mcpServers'], confidence: 'medium', file: (root) => path.join(root, '.gemini', 'settings.json') },
+  { tool: 'codex-cli', scope: 'home', read: readTomlMcpServerNames, confidence: 'high', file: () => path.join(codexHome(), 'config.toml') },
+  { tool: 'pi', scope: 'home', keys: ['mcpServers'], confidence: 'high', file: () => path.join(piAgentDir(), 'mcp.json') },
+  { tool: 'pi', scope: 'project', keys: ['mcpServers'], confidence: 'high', file: (root) => path.join(root, '.pi', 'mcp.json') },
+  { tool: 'opencode', scope: 'home', keys: ['mcp'], confidence: 'medium', file: (root, home) => path.join(home, '.config', 'opencode', 'opencode.json') },
+  { tool: 'opencode', scope: 'project', keys: ['mcp'], confidence: 'medium', file: (root) => path.join(root, 'opencode.json') },
   // VS Code: `servers`, not `mcpServers`, and three OS-specific user paths.
   { tool: null, scope: 'project', keys: ['servers', 'mcpServers'], confidence: 'medium', file: (root) => path.join(root, '.vscode', 'mcp.json') },
   { tool: null, scope: 'home', keys: ['servers', 'mcpServers'], confidence: 'medium', file: (root, home) => path.join(home, 'Library', 'Application Support', 'Code', 'User', 'mcp.json') },
@@ -134,6 +140,23 @@ function readMcpServerNames(file, keys = ['mcpServers']) {
   return [];
 }
 
+const TOML_MCP_TABLE = /^\s*\[\s*mcp_servers\.(?:"([^"]+)"|'([^']+)'|([A-Za-z0-9_-]+))/;
+
+function readTomlMcpServerNames(file) {
+  let raw;
+  try {
+    raw = fs.readFileSync(file, 'utf8');
+  } catch {
+    return [];
+  }
+  const names = new Set();
+  for (const line of raw.split(/\r?\n/)) {
+    const m = TOML_MCP_TABLE.exec(line);
+    if (m) names.add(m[1] || m[2] || m[3]);
+  }
+  return [...names];
+}
+
 // Deterministic (no-LLM) MCP-by-name detection over every location in `MCP_CONFIG_LOCATIONS` (project ∪ home).
 function detectMcpServers(root) {
   const home = getHomeDir();
@@ -148,7 +171,7 @@ function detectMcpServers(root) {
     } catch {
       continue; // an unresolvable home never breaks the other locations
     }
-    const names = readMcpServerNames(file, loc.keys);
+    const names = (loc.read ? loc.read(file) : readMcpServerNames(file, loc.keys)).filter((n) => !OWN_MCP_SERVER_NAMES.has(n));
     if (loc.tool && names.length) {
       // Per-tool count is the union across THAT tool's own locations, so a
       // server configured both in the project and globally counts once for it.
@@ -220,4 +243,5 @@ module.exports = {
   serviceForMcpServerName,
   MCP_CONFIG_LOCATIONS,
   SERVICE_CATALOG,
+  readTomlMcpServerNames,
 };