simple-answers 1.0.0

package/.claude-plugin/marketplace.json

@@ -0,0 +1,14 @@
+{
+  "name": "simple-answers",
+  "owner": {
+    "name": "tehseenullah786"
+  },
+  "plugins": [
+    {
+      "name": "simple-answers",
+      "source": "./",
+      "description": "Makes Claude answer in short, simple English."
+    }
+  ],
+  "description": "Plugins that make Claude answer in short, simple English."
+}

package/.claude-plugin/plugin.json

@@ -0,0 +1,14 @@
+{
+  "name": "simple-answers",
+  "description": "Makes Claude answer in short, simple English. Answer first, no jargon, no long walls of text.",
+  "version": "1.0.0",
+  "author": {
+    "name": "tehseenullah786"
+  },
+  "keywords": [
+    "plain-english",
+    "short-answers",
+    "eli5",
+    "readability"
+  ]
+}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 tehseenullah786
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,141 @@
+# Simple Answers
+
+Make AI answers **short and easy to read**.
+
+Answer first. Small sentences. No jargon. No wall of text.
+
+Works in Claude Code, Claude Desktop, Cursor, and any app that supports MCP.
+
+---
+
+## Install (MCP — works everywhere)
+
+**Claude Code**
+
+```bash
+claude mcp add simple-answers -- npx -y simple-answers
+```
+
+**Claude Desktop / Cursor** — add this to the MCP config file:
+
+```json
+{
+  "mcpServers": {
+    "simple-answers": {
+      "command": "npx",
+      "args": ["-y", "simple-answers"]
+    }
+  }
+}
+```
+
+Nothing to download first. `npx` fetches it for you.
+
+---
+
+## What you get
+
+### Tools (the AI calls these)
+
+| Tool | What it does |
+|---|---|
+| `check_readability` | Scores text. Finds long sentences, hard words, filler. Real maths, no AI. |
+| `simplify` | Gives the AI the exact rules + the score, so it rewrites your text simply. |
+| `style_rules` | Turns on plain-English mode for the rest of the chat. |
+
+### Prompts (you pick these)
+
+In Claude Code they appear as slash commands:
+
+| Prompt | What it does |
+|---|---|
+| `/simple` | Simple mode ON — and say the last answer again in easy words |
+| `/simple-off` | Simple mode OFF — normal replies again |
+
+---
+
+## Example
+
+Ask it to check this sentence:
+
+> Notwithstanding the erroneous implementation, we will utilize the existing
+> paradigm in order to facilitate a seamless migration.
+
+It answers:
+
+```
+Reading ease: -5 (very hard). Target: 60 or more.
+Length: 26 words, 1 sentences, 26 words per sentence. Target: 18 or fewer.
+
+Replace these words:
+  notwithstanding -> even so
+  erroneous       -> wrong
+  utilize         -> use
+  paradigm        -> model
+  facilitate      -> help
+  seamless        -> smooth
+
+Filler to delete: in order to
+```
+
+Good for README files, error messages, docs and UI text — not only chat.
+
+---
+
+## Also: a Claude Code plugin
+
+The same repo is a Claude Code plugin. The plugin adds one extra thing the MCP
+server cannot do: a **hook** that puts the plain-English rules into *every*
+message automatically, with no tool call.
+
+```bash
+/plugin marketplace add tehseenullah786/simple-answers
+/plugin install simple-answers@simple-answers
+```
+
+### Short command names
+
+Plugin commands are typed with the plugin name in front:
+`/simple-answers:simple`, `/simple-answers:simple-off`.
+
+To type just `/simple` and `/simple-off`, run this once:
+
+```bash
+./install-shortcuts.sh
+```
+
+It copies the commands into `~/.claude/commands/`. Restart Claude Code after.
+
+Turn it off and on — just type:
+
+```
+/simple-off    normal replies again
+/simple        simple replies again
+```
+
+MCP or plugin — which one?
+
+| You want | Use |
+|---|---|
+| Simple answers in Claude Desktop, Cursor, other apps | MCP |
+| Simple answers in Claude Code, automatic every time | plugin |
+| Both | install both — they work together |
+
+---
+
+## Change the rules
+
+- MCP rules: `src/server.js`, the `STYLE_RULES` text at the top.
+- Word replacements: `src/readability.js`, the `JARGON` list.
+- Plugin hook: `hooks/simple-style.sh`.
+
+## Develop
+
+```bash
+npm install
+npm test        # talks to the server over stdio and prints the output
+```
+
+## License
+
+MIT

package/bin/cli.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { main } from "../src/server.js";
+
+main().catch((err) => {
+  console.error("[simple-answers] failed to start:", err);
+  process.exit(1);
+});

package/commands/simple-off.md

@@ -0,0 +1,11 @@
+---
+description: Simple answers OFF — normal, full replies again
+allowed-tools: Bash(touch:*)
+---
+
+!`touch "$HOME/.claude/simple-answers-off" && echo "simple mode off"`
+
+Say exactly this to the user and nothing else:
+
+**Simple mode is OFF.** Normal replies start from your next message.
+Turn it back on with `/simple`.

package/commands/simple.md

@@ -0,0 +1,23 @@
+---
+description: Simple answers ON — short, easy English from now on
+allowed-tools: Bash(rm:*)
+---
+
+!`rm -f "$HOME/.claude/simple-answers-off" && echo "simple mode on"`
+
+Simple mode is now ON. Every answer from now on is short and easy.
+
+Now say your **previous answer** again, simply:
+
+- 80 words maximum.
+- Sentences of 12 words or fewer.
+- No technical words. If one is unavoidable, explain it in brackets.
+- Start with the most important point.
+- 4 bullets maximum.
+- Keep every command and file path exactly as it was.
+
+Do not do new work. Only rewrite what you already said.
+
+If there is no previous answer, just say one line: "Simple mode is on. Ask me anything."
+
+$ARGUMENTS

package/hooks/hooks.json

@@ -0,0 +1,14 @@
+{
+  "hooks": {
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/simple-style.sh"
+          }
+        ]
+      }
+    ]
+  }
+}

package/hooks/simple-style.sh

@@ -0,0 +1,33 @@
+#!/usr/bin/env bash
+# simple-answers: adds plain-English writing rules to every prompt.
+# Turn it off:  touch ~/.claude/simple-answers-off
+# Turn it on :  rm -f ~/.claude/simple-answers-off
+
+set -u
+
+STATE_FILE="${HOME:-/nonexistent}/.claude/simple-answers-off"
+[ -f "$STATE_FILE" ] && exit 0
+
+cat <<'RULES'
+<simple-answers-style>
+How to write your reply to the user (writing style only — never change the
+correctness or completeness of the work itself):
+
+1. Put the answer in the FIRST sentence. No warm-up, no repeating the question.
+2. Short sentences. Aim for 15 words or fewer. One idea per sentence.
+3. Easy words. No jargon. If a technical word is required, put a 3-5 word
+   meaning right after it in brackets.
+4. Keep the whole reply under ~120 words, unless the user asked for detail,
+   asked for a plan, or the answer is a list of steps.
+5. Use bullets or numbered steps for anything with more than two parts.
+6. Say what you did and what the user should do next. Skip the reasoning
+   story, skip the options you did not take, skip the summary of the summary.
+7. Bold the one thing that matters most, if anything does.
+8. Code blocks, file paths and commands stay exact and complete. Simplify the
+   words around the code, never the code.
+9. If the honest answer is "I don't know" or "it failed", say that plainly.
+
+The user is not a native English speaker. Clear beats clever.
+</simple-answers-style>
+RULES
+exit 0

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "simple-answers",
+  "version": "1.0.0",
+  "description": "MCP server that makes AI answers short and easy to read. Scores text for readability and rewrites it in plain English.",
+  "type": "module",
+  "bin": {
+    "simple-answers": "bin/cli.js"
+  },
+  "main": "src/server.js",
+  "files": [
+    "bin",
+    "src",
+    "commands",
+    "hooks",
+    "skills",
+    ".claude-plugin",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "mcp",
+    "modelcontextprotocol",
+    "claude",
+    "plain-english",
+    "readability",
+    "eli5",
+    "simplify"
+  ],
+  "license": "MIT",
+  "author": "tehseenullah786",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.30.0"
+  },
+  "scripts": {
+    "start": "node bin/cli.js",
+    "test": "node test/smoke.js && node test/full-test.mjs"
+  }
+}

package/skills/plain-english/SKILL.md

@@ -0,0 +1,39 @@
+---
+name: plain-english
+description: Explain code, errors, logs or documents in simple English for a non-native speaker. Use when the user says they do not understand, asks "what does this mean", "explain simply", "in easy words", "I am confused", or asks for an explanation of an error message, a file, or a technical document.
+---
+
+# Plain English
+
+Explain the thing so a smart person with basic English understands it.
+
+## Shape of the answer
+
+1. **One sentence: what it is.**
+2. **One sentence: why it matters to the user right now.**
+3. Then, only if needed, 3-5 bullets of detail.
+4. Last line: what to do next.
+
+## Rules
+
+- 12-15 words per sentence. One idea per sentence.
+- Use everyday words: "run" not "execute", "fix" not "remediate",
+  "sends" not "dispatches", "wrong" not "erroneous".
+- Every technical word gets a meaning in brackets the first time:
+  "a signal (a message the app sends when something happens)".
+- Use a small real-world comparison when a concept is abstract.
+- Never paste a long block of code or logs back to the user. Quote the one
+  line that matters and say what it means.
+- Do not apologise, do not flatter, do not add "I hope this helps".
+
+## For an error message
+
+Answer in this order:
+- What broke, in plain words.
+- The one line in the error that proves it (file and line number).
+- The fix, as a command or a small edit.
+
+## What not to simplify
+
+Commands, file paths, variable names, and code stay exact. Making a command
+"simpler" makes it wrong.

package/src/readability.js

@@ -0,0 +1,222 @@
+/**
+ * Deterministic readability analysis. No AI, no network.
+ * Everything here is plain arithmetic over the text.
+ */
+
+/** Words that look hard by syllable count but are everyday English. */
+const COMMON_LONG_WORDS = new Set([
+  "another", "anything", "everything", "everyone", "everybody", "already",
+  "understand", "understanding", "different", "important", "example",
+  "remember", "together", "usually", "probably", "actually", "family",
+  "company", "area", "video", "audio", "idea", "every", "never", "over",
+  "into", "open", "easy", "easier", "easiest", "only", "also", "even",
+  "many", "money", "people", "using", "user", "users", "other", "others",
+  "before", "after", "about", "because", "however", "final", "finally",
+]);
+
+/** Jargon -> plain replacement. Kept short on purpose: only common offenders. */
+const JARGON = {
+  utilize: "use",
+  utilise: "use",
+  leverage: "use",
+  facilitate: "help",
+  implement: "build",
+  instantiate: "create",
+  initialize: "set up",
+  initialise: "set up",
+  terminate: "stop",
+  execute: "run",
+  invoke: "call",
+  propagate: "pass on",
+  aggregate: "collect",
+  disseminate: "share",
+  remediate: "fix",
+  mitigate: "reduce",
+  ascertain: "find out",
+  endeavor: "try",
+  endeavour: "try",
+  commence: "start",
+  cease: "stop",
+  prior: "before",
+  subsequent: "next",
+  subsequently: "then",
+  additionally: "also",
+  furthermore: "also",
+  moreover: "also",
+  nevertheless: "but",
+  notwithstanding: "even so",
+  approximately: "about",
+  sufficient: "enough",
+  numerous: "many",
+  obtain: "get",
+  provide: "give",
+  require: "need",
+  attempt: "try",
+  demonstrate: "show",
+  indicate: "show",
+  modify: "change",
+  optimize: "improve",
+  optimise: "improve",
+  erroneous: "wrong",
+  anomaly: "problem",
+  paradigm: "model",
+  robust: "strong",
+  granular: "detailed",
+  holistic: "complete",
+  seamless: "smooth",
+  canonical: "standard",
+  idempotent: "safe to repeat",
+  deterministic: "always the same",
+  asynchronous: "not waiting",
+  orchestrate: "coordinate",
+};
+
+const HEDGES = [
+  "it is worth noting", "it should be noted", "as you may know",
+  "i hope this helps", "please note that", "in order to",
+  "at the end of the day", "needless to say", "it is important to note",
+  "that being said", "with that said", "as previously mentioned",
+];
+
+/** Strip fenced code, inline code and URLs — those must never be simplified. */
+export function stripCode(text) {
+  return text
+    .replace(/```[\s\S]*?```/g, " ")
+    .replace(/`[^`\n]*`/g, " ")
+    .replace(/https?:\/\/\S+/g, " ")
+    .replace(/^\s*[|+].*$/gm, " ");
+}
+
+export function countSyllables(word) {
+  const w = word.toLowerCase().replace(/[^a-z]/g, "");
+  if (!w) return 0;
+  if (w.length <= 3) return 1;
+  const trimmed = w
+    .replace(/(?:[^laeiouy]es|ed|[^laeiouy]e)$/, "")
+    .replace(/^y/, "");
+  const groups = trimmed.match(/[aeiouy]{1,2}/g);
+  return groups ? groups.length : 1;
+}
+
+export function splitSentences(text) {
+  return text
+    .split(/(?<=[.!?])\s+|\n{2,}|\n(?=[-*\d])/)
+    .map((s) => s.trim())
+    .filter((s) => s.replace(/[^a-zA-Z]/g, "").length > 1);
+}
+
+export function splitWords(text) {
+  return text.match(/[A-Za-z][A-Za-z'’-]*/g) || [];
+}
+
+/** Flesch Reading Ease: 90-100 very easy, 60-70 plain, below 30 very hard. */
+export function fleschReadingEase(words, sentences, syllables) {
+  if (!words || !sentences) return 100;
+  return 206.835 - 1.015 * (words / sentences) - 84.6 * (syllables / words);
+}
+
+export function easeLabel(score) {
+  if (score >= 80) return "very easy";
+  if (score >= 60) return "easy — good for a non-native reader";
+  if (score >= 50) return "a bit hard";
+  if (score >= 30) return "hard";
+  return "very hard";
+}
+
+export function analyze(rawText, { maxSentenceWords = 18 } = {}) {
+  const text = stripCode(String(rawText || ""));
+  const sentences = splitSentences(text);
+  const words = splitWords(text);
+  const syllables = words.reduce((n, w) => n + countSyllables(w), 0);
+
+  const ease = fleschReadingEase(words.length, sentences.length, syllables);
+  const avgSentence = sentences.length ? words.length / sentences.length : 0;
+
+  const longSentences = sentences
+    .map((s, i) => ({ index: i + 1, words: splitWords(s).length, text: s }))
+    .filter((s) => s.words > maxSentenceWords)
+    .sort((a, b) => b.words - a.words)
+    .slice(0, 8);
+
+  const hardWords = [];
+  const seenHard = new Set();
+  for (const w of words) {
+    const lower = w.toLowerCase();
+    if (seenHard.has(lower)) continue;
+    if (COMMON_LONG_WORDS.has(lower)) continue;
+    if (lower.length < 8) continue;
+    if (countSyllables(lower) >= 4) {
+      seenHard.add(lower);
+      hardWords.push(lower);
+    }
+  }
+
+  const jargon = [];
+  const seenJargon = new Set();
+  for (const w of words) {
+    const lower = w.toLowerCase();
+    const base = lower.replace(/(s|es|ed|ing|ly)$/, "");
+    const hit = JARGON[lower] ?? JARGON[base];
+    if (hit && !seenJargon.has(lower)) {
+      seenJargon.add(lower);
+      jargon.push({ word: lower, use: hit });
+    }
+  }
+
+  const lowerText = text.toLowerCase();
+  const hedges = HEDGES.filter((h) => lowerText.includes(h));
+
+  return {
+    words: words.length,
+    sentences: sentences.length,
+    avgSentenceWords: Number(avgSentence.toFixed(1)),
+    readingEase: Number(ease.toFixed(1)),
+    readingEaseLabel: easeLabel(ease),
+    longSentences,
+    hardWords: hardWords.slice(0, 15),
+    jargon: jargon.slice(0, 15),
+    hedges,
+    passes:
+      ease >= 60 &&
+      avgSentence <= maxSentenceWords &&
+      jargon.length === 0 &&
+      hedges.length === 0,
+  };
+}
+
+export function formatReport(r, { maxWords } = {}) {
+  const lines = [];
+  lines.push(
+    `Reading ease: ${r.readingEase} (${r.readingEaseLabel}). Target: 60 or more.`
+  );
+  lines.push(
+    `Length: ${r.words} words, ${r.sentences} sentences, ${r.avgSentenceWords} words per sentence. Target: 18 or fewer.`
+  );
+  if (maxWords && r.words > maxWords) {
+    lines.push(`Too long: cut to ${maxWords} words or fewer.`);
+  }
+
+  if (r.longSentences.length) {
+    lines.push("", "Sentences to split (longest first):");
+    for (const s of r.longSentences) {
+      lines.push(`  [${s.words} words] ${s.text.slice(0, 160)}`);
+    }
+  }
+  if (r.jargon.length) {
+    lines.push("", "Replace these words:");
+    for (const j of r.jargon) lines.push(`  ${j.word} -> ${j.use}`);
+  }
+  if (r.hardWords.length) {
+    lines.push(
+      "",
+      `Hard words (explain in brackets or replace): ${r.hardWords.join(", ")}`
+    );
+  }
+  if (r.hedges.length) {
+    lines.push("", `Filler to delete: ${r.hedges.join("; ")}`);
+  }
+  if (r.passes) {
+    lines.push("", "This text already reads well. Do not rewrite it.");
+  }
+  return lines.join("\n");
+}

package/src/server.js

@@ -0,0 +1,217 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { analyze, formatReport } from "./readability.js";
+
+const STYLE_RULES = `Write the reply like this:
+1. Answer in the first sentence. No warm-up, no repeating the question.
+2. Short sentences, 15 words or fewer. One idea per sentence.
+3. Everyday words only. A needed technical word gets a 3-5 word meaning in brackets.
+4. Bullets or numbered steps for anything with more than two parts.
+5. Say what to do next. Cut the reasoning story and the summary of the summary.
+6. Commands, file paths and code stay exact. Simplify the words, never the code.
+7. If something failed or is unknown, say so plainly.`;
+
+export function createServer() {
+  const server = new McpServer({
+    name: "simple-answers",
+    version: "1.0.0",
+  });
+
+  server.registerTool(
+    "check_readability",
+    {
+      title: "Check readability",
+      description:
+        "Score text for plain-English readability. Returns a Flesch reading-ease score, sentences that are too long, jargon with plain replacements, and filler phrases. Pure arithmetic — no AI, no network. Use it before sending a long explanation, or to check a README, docs page, error message or UI copy.",
+      inputSchema: {
+        text: z.string().describe("The text to score."),
+        maxSentenceWords: z
+          .number()
+          .int()
+          .min(5)
+          .max(60)
+          .optional()
+          .describe("Longest allowed sentence, in words. Default 18."),
+      },
+    },
+    async ({ text, maxSentenceWords }) => {
+      const result = analyze(text, { maxSentenceWords });
+      return {
+        content: [{ type: "text", text: formatReport(result) }],
+        structuredContent: result,
+      };
+    }
+  );
+
+  server.registerTool(
+    "simplify",
+    {
+      title: "Simplify text",
+      description:
+        "Get the exact instructions and readability numbers needed to rewrite a piece of text in simple English. Returns the problems found plus the rules to follow; you then write the simpler version yourself. Use when the user says they do not understand, asks for easy words, or asks for a shorter answer.",
+      inputSchema: {
+        text: z.string().describe("The text to simplify."),
+        maxWords: z
+          .number()
+          .int()
+          .min(10)
+          .max(2000)
+          .optional()
+          .describe("Word budget for the rewrite. Default 120."),
+        audience: z
+          .string()
+          .optional()
+          .describe(
+            "Who is reading, e.g. 'non-native English speaker', 'beginner', 'manager'."
+          ),
+      },
+    },
+    async ({ text, maxWords = 120, audience }) => {
+      const result = analyze(text);
+      const parts = [
+        `Rewrite the text below in simple English. Reader: ${
+          audience || "a non-native English speaker"
+        }. Budget: ${maxWords} words or fewer.`,
+        "",
+        STYLE_RULES,
+        "",
+        "What the text scores now:",
+        formatReport(result, { maxWords }),
+        "",
+        "Reply with the rewritten text only. No preface, no notes about the rewrite.",
+      ];
+      return {
+        content: [{ type: "text", text: parts.join("\n") }],
+        structuredContent: result,
+      };
+    }
+  );
+
+  server.registerTool(
+    "style_rules",
+    {
+      title: "Plain-English style rules",
+      description:
+        "Return the plain-English writing rules to follow for the rest of the conversation. Call once when the user asks for simple, short, or easy answers.",
+      inputSchema: {},
+    },
+    async () => ({
+      content: [
+        {
+          type: "text",
+          text: `${STYLE_RULES}\n\nKeep following these rules until the user asks for more detail.`,
+        },
+      ],
+    })
+  );
+
+  server.registerPrompt(
+    "simple",
+    {
+      title: "Say it simply",
+      description: "Say the last answer again in very simple English.",
+    },
+    () => ({
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: `Say your previous answer again, simply.
+
+- 80 words maximum.
+- Sentences of 12 words or fewer.
+- No technical words. If one is unavoidable, explain it in brackets.
+- Start with the most important point.
+- 4 bullets maximum.
+- Keep every command and file path exactly as it was.
+
+Do not do new work. Only rewrite what you already said.`,
+          },
+        },
+      ],
+    })
+  );
+
+  server.registerPrompt(
+    "tldr",
+    {
+      title: "One line",
+      description: "The last answer in one sentence.",
+    },
+    () => ({
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: "Reply with one single sentence, 25 words maximum, that captures your previous answer. No bullets, no heading, no code block, nothing else.",
+          },
+        },
+      ],
+    })
+  );
+
+  server.registerPrompt(
+    "steps",
+    {
+      title: "Give me steps",
+      description: "Turn the last answer into a numbered checklist.",
+    },
+    () => ({
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: `Turn your previous answer into a numbered checklist I can follow.
+
+- One action per step, starting with a verb.
+- 12 words or fewer per step, plus the command on its own line if needed.
+- 7 steps maximum. Merge small steps.
+- No text before or after the list.`,
+          },
+        },
+      ],
+    })
+  );
+
+  server.registerPrompt(
+    "explain",
+    {
+      title: "Explain simply",
+      description: "Explain something in plain English.",
+      argsSchema: {
+        topic: z.string().describe("What to explain."),
+      },
+    },
+    ({ topic }) => ({
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: `Explain this in plain English: ${topic}
+
+Shape of your answer:
+1. One sentence: what it is.
+2. One sentence: why it matters to me.
+3. 3-5 short bullets of detail, only if needed.
+4. Last line: what I should do next.
+
+Sentences of 15 words or fewer. Everyday words. Every technical word gets a short meaning in brackets. Do not paste long code or logs back at me — quote the one line that matters.`,
+          },
+        },
+      ],
+    })
+  );
+
+  return server;
+}
+
+export async function main() {
+  const server = createServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}