diff --git a/.eslintrc.js b/.eslintrc.js
index 7d6108d36b..0ae9576963 100644
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -148,6 +148,40 @@ module.exports = {
       rules: {
         '@typescript-eslint/no-non-null-assertion': 'off',
       }
-    }
+    },
+    {
+      files: ['scripts/*.js'],
+      env: {
+        node: true,
+      },
+      rules: {
+        '@typescript-eslint/no-var-requires': 'off',
+        '@typescript-eslint/no-unsafe-argument': 'off',
+        '@typescript-eslint/no-unsafe-assignment': 'off',
+        '@typescript-eslint/no-unsafe-call': 'off',
+        '@typescript-eslint/no-unsafe-member-access': 'off',
+        '@typescript-eslint/no-unsafe-return': 'off',
+        '@typescript-eslint/restrict-template-expressions': 'off',
+        'no-undef': 'off',
+      },
+    },
+    {
+      // Plain-Node Jest specs (e.g. docs tooling tests that `require` JS modules
+      // rather than importing typed sources). Same relaxations as `scripts/*.js`.
+      files: ['**/test/**/*.spec.js'],
+      env: {
+        node: true,
+      },
+      rules: {
+        '@typescript-eslint/no-var-requires': 'off',
+        '@typescript-eslint/no-unsafe-argument': 'off',
+        '@typescript-eslint/no-unsafe-assignment': 'off',
+        '@typescript-eslint/no-unsafe-call': 'off',
+        '@typescript-eslint/no-unsafe-member-access': 'off',
+        '@typescript-eslint/no-unsafe-return': 'off',
+        '@typescript-eslint/restrict-template-expressions': 'off',
+        'no-undef': 'off',
+      },
+    },
   ],
 }
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 683e1da144..5ff2d8700b 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,6 +9,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 
 ### Added
 
+- Added agent-friendly documentation: per-page `.md` companions, a Copy-Markdown button, an `llms.txt` index, and a coding-agent setup guide. [#1696](https://github.com/handsontable/hyperformula/pull/1696)
 - Added an Indonesian (Bahasa Indonesia) language pack. [#1674](https://github.com/handsontable/hyperformula/pull/1674)
 
 ## [3.3.0] - 2026-05-20
diff --git a/context7.json b/context7.json
new file mode 100644
index 0000000000..529df28606
--- /dev/null
+++ b/context7.json
@@ -0,0 +1,14 @@
+{
+  "$schema": "https://context7.com/schema/context7.json",
+  "projectTitle": "HyperFormula",
+  "description": "Headless, Excel-compatible spreadsheet engine in TypeScript — parses and evaluates ~400 functions in the browser or Node.js. In-process library (no REST API).",
+  "folders": ["docs"],
+  "excludeFolders": ["docs/.vuepress/dist", "docs/api"],
+  "rules": [
+    "HyperFormula is an in-process library, not a REST API — there is no HTTP endpoint or base URL.",
+    "Public API cell addresses are 0-indexed: { sheet, col, row }.",
+    "There is no #CALC! error type.",
+    "EmptyValue is exported as a Symbol, not null/undefined.",
+    "A license key is required when constructing the engine (use 'gpl-v3' for open-source use)."
+  ]
+}
diff --git a/docs/.vuepress/components/CodingAgentWizard.vue b/docs/.vuepress/components/CodingAgentWizard.vue
new file mode 100644
index 0000000000..e5208374e2
--- /dev/null
+++ b/docs/.vuepress/components/CodingAgentWizard.vue
@@ -0,0 +1,104 @@
+<template>
+  <div class="agent-wizard">
+    <div v-if="!selected" class="agent-wizard__choices">
+      <p class="agent-wizard__prompt">Which coding agent do you use?</p>
+      <button
+        v-for="opt in options"
+        :key="opt.id"
+        class="agent-wizard__choice"
+        type="button"
+        @click="selected = opt.id"
+      >{{ opt.label }}</button>
+    </div>
+
+    <div v-else class="agent-wizard__result">
+      <button class="agent-wizard__back" type="button" @click="reset">&larr; Change</button>
+      <h3>{{ current.label }}</h3>
+      <pre class="agent-wizard__snippet"><code>{{ current.snippet }}</code></pre>
+      <button class="agent-wizard__copy" type="button" @click="copy">{{ copied ? 'Copied!' : 'Copy' }}</button>
+      <p class="agent-wizard__note" v-html="current.note"></p>
+    </div>
+  </div>
+</template>
+
+<script>
+export default {
+  name: 'CodingAgentWizard',
+  data() {
+    return {
+      selected: null,
+      copied: false,
+      options: [
+        {
+          id: 'claude-code',
+          label: 'Claude Code',
+          snippet: '/plugin marketplace add handsontable/handsontable-skills\n/plugin install handsontable-skills@handsontable-skills',
+          note: 'Installs the official <code>hyperformula</code> skill. Claude Code loads it automatically.',
+        },
+        {
+          id: 'cursor',
+          label: 'Cursor',
+          snippet: 'Add to your AGENTS.md / rules file:\nHyperFormula docs (LLM-friendly): https://hyperformula.handsontable.com/docs/llms-full.txt',
+          note: 'Cursor has no Claude-skill installer yet — point it at the full docs corpus instead.',
+        },
+        {
+          id: 'copilot',
+          label: 'GitHub Copilot',
+          snippet: 'Add to .github/copilot-instructions.md:\nReference HyperFormula docs: https://hyperformula.handsontable.com/docs/llms-full.txt',
+          note: 'Copilot reads an instructions file — link it to the corpus so it fetches authoritative docs.',
+        },
+        {
+          id: 'other',
+          label: 'Other / API',
+          snippet: 'curl -s https://hyperformula.handsontable.com/docs/llms-full.txt',
+          note: 'Fetch the full corpus, or upload the skill folder from <code>handsontable/handsontable-skills</code> to the Claude API.',
+        },
+      ],
+    };
+  },
+  computed: {
+    current() {
+      return this.options.find(o => o.id === this.selected) || null;
+    },
+  },
+  methods: {
+    reset() { this.selected = null; this.copied = false; },
+    copy() {
+      if (!this.current) return;
+      const text = this.current.snippet;
+      const fallback = (t) => {
+        const el = document.createElement('textarea');
+        el.value = t;
+        el.style.position = 'fixed';
+        el.style.opacity = '0';
+        document.body.appendChild(el);
+        el.select();
+        try { document.execCommand('copy'); } finally { document.body.removeChild(el); }
+      };
+      const done = () => { this.copied = true; setTimeout(() => { this.copied = false; }, 1500); };
+      if (navigator.clipboard && window.isSecureContext) {
+        navigator.clipboard.writeText(text).then(done).catch(() => { fallback(text); done(); });
+      } else {
+        fallback(text);
+        done();
+      }
+    },
+  },
+};
+</script>
+
+<style scoped>
+.agent-wizard { border: 1px solid #eaecef; border-radius: 6px; padding: 1rem 1.25rem; margin: 1.5rem 0; }
+.agent-wizard__prompt { font-weight: 600; margin: 0 0 0.75rem; }
+.agent-wizard__choice,
+.agent-wizard__copy,
+.agent-wizard__back {
+  cursor: pointer; border: 1px solid #3eaf7c; background: #fff; color: #3eaf7c;
+  border-radius: 4px; padding: 0.4rem 0.8rem; margin: 0 0.5rem 0.5rem 0; font-size: 0.9rem;
+}
+.agent-wizard__choice:hover,
+.agent-wizard__copy:hover { background: #3eaf7c; color: #fff; }
+.agent-wizard__back { border-color: #ccc; color: #666; }
+.agent-wizard__snippet { background: #f6f6f6; padding: 0.75rem; border-radius: 4px; overflow-x: auto; }
+.agent-wizard__note { font-size: 0.85rem; color: #666; }
+</style>
diff --git a/docs/.vuepress/components/CopyMarkdownButton.vue b/docs/.vuepress/components/CopyMarkdownButton.vue
new file mode 100644
index 0000000000..018ec1727c
--- /dev/null
+++ b/docs/.vuepress/components/CopyMarkdownButton.vue
@@ -0,0 +1,67 @@
+<template>
+  <button
+    v-if="mdUrl"
+    class="copy-md-button"
+    type="button"
+    :title="'Copy this page as Markdown URL for LLMs'"
+    @click="copy"
+  >{{ label }}</button>
+</template>
+
+<script>
+export default {
+  name: 'CopyMarkdownButton',
+  data() {
+    return { copied: false };
+  },
+  computed: {
+    mdUrl() {
+      const p = this.$page && this.$page.path;
+      if (!p || !/\.html$/.test(p)) return null;
+      return this.$withBase(p.replace(/\.html$/, '.md'));
+    },
+    label() {
+      return this.copied ? 'Copied!' : 'Copy Markdown';
+    },
+  },
+  methods: {
+    copy() {
+      const absolute = window.location.origin + this.mdUrl;
+      const fallback = (text) => {
+        const el = document.createElement('textarea');
+        el.value = text;
+        el.style.position = 'fixed';
+        el.style.opacity = '0';
+        document.body.appendChild(el);
+        el.select();
+        try { document.execCommand('copy'); } finally { document.body.removeChild(el); }
+      };
+      const done = () => { this.copied = true; setTimeout(() => { this.copied = false; }, 1500); };
+      if (navigator.clipboard && window.isSecureContext) {
+        navigator.clipboard.writeText(absolute).then(done).catch(() => { fallback(absolute); done(); });
+      } else {
+        fallback(absolute);
+        done();
+      }
+    },
+  },
+};
+</script>
+
+<style scoped>
+.copy-md-button {
+  position: fixed;
+  bottom: 1.5rem;
+  right: 1.5rem;
+  z-index: 100;
+  padding: 0.5rem 0.9rem;
+  font-size: 0.85rem;
+  border: 1px solid #3eaf7c;
+  border-radius: 4px;
+  background: #fff;
+  color: #3eaf7c;
+  cursor: pointer;
+  box-shadow: 0 1px 4px rgba(0,0,0,0.12);
+}
+.copy-md-button:hover { background: #3eaf7c; color: #fff; }
+</style>
diff --git a/docs/.vuepress/config.js b/docs/.vuepress/config.js
index d185119bc9..2e4862a6a5 100644
--- a/docs/.vuepress/config.js
+++ b/docs/.vuepress/config.js
@@ -5,6 +5,7 @@ const searchBoxPlugin = require('./plugins/search-box');
 const examples = require('./plugins/examples/examples');
 const HyperFormula = require('../../dist/hyperformula.full');
 const includeCodeSnippet = require('./plugins/markdown-it-include-code-snippet');
+const mdCompanions = require('./plugins/md-companions');
 
 const searchPattern = new RegExp('^/api', 'i');
 
@@ -31,7 +32,7 @@ const DOCS_HOSTNAME = process.env.DOCS_HOSTNAME || buildConfigOverrides.hostname
 module.exports = {
   title: 'HyperFormula (v' + HyperFormula.version + ')',
   description: 'HyperFormula is an open-source, high-performance calculation engine for spreadsheets and web applications.',
-  globalUIComponents: [],
+  globalUIComponents: ['CopyMarkdownButton'],
   head: [
     // Import HF (required for the examples)
     [ 'script', { src: 'https://cdn.jsdelivr.net/npm/hyperformula/dist/hyperformula.full.min.js' } ],
@@ -89,6 +90,7 @@ module.exports = {
       exclude: ['/404.html'],
       changefreq: 'weekly'
     }],
+    [mdCompanions, { hostname: DOCS_HOSTNAME }],
     searchBoxPlugin,
     ['container', examples()],
     {
@@ -206,6 +208,7 @@ module.exports = {
             ['/guide/advanced-usage', 'Advanced usage'],
             ['/guide/configuration-options', 'Configuration options'],
             ['/guide/license-key', 'License key'],
+            ['/guide/setup-coding-agent', 'Set up your coding agent'],
           ]
         },
         {
diff --git a/docs/.vuepress/plugins/md-companions/index.js b/docs/.vuepress/plugins/md-companions/index.js
new file mode 100644
index 0000000000..ef0c2044cc
--- /dev/null
+++ b/docs/.vuepress/plugins/md-companions/index.js
@@ -0,0 +1,44 @@
+const fs = require('fs');
+const path = require('path');
+const { stripVuePressSyntax } = require('./strip');
+
+/**
+ * VuePress plugin: after build, write a clean `.md` companion next to each
+ * rendered `.html`, plus an aggregate `llms-full.txt`. Respects ctx.outDir
+ * (which already includes the configured base segment).
+ * @param {object} options plugin options
+ * @param {object} ctx VuePress app context
+ */
+module.exports = (options, ctx) => ({
+  name: 'md-companions',
+  async generated() {
+    const hostname = (options && options.hostname) || 'https://hyperformula.handsontable.com';
+    const base = ctx.base || '/';
+    const pages = ctx.pages.filter(p => /\.html$/.test(p.path) && p.path !== '/404.html');
+    const corpus = [
+      '# HyperFormula Documentation',
+      '',
+      '> Full documentation corpus for LLM consumption.',
+      `> Individual pages also available at ${hostname}${base}guide/<slug>.md`,
+      '',
+    ];
+
+    for (const page of pages) {
+      try {
+        const clean = stripVuePressSyntax(page._strippedContent || '');
+        const relPath = page.path.replace(/\.html$/, '.md');
+        const outFile = path.join(ctx.outDir, relPath.replace(/^\//, ''));
+        await fs.promises.mkdir(path.dirname(outFile), { recursive: true });
+        await fs.promises.writeFile(outFile, clean, 'utf8');
+
+        const url = hostname + base.replace(/\/$/, '') + page.path.replace(/\.html$/, '');
+        corpus.push('---', '', `## ${page.title || page.path}`, '', `URL: ${url}`, '', clean, '');
+      } catch (err) {
+        console.warn(`[md-companions] skipping ${page.path}: ${err.message}`);
+      }
+    }
+
+    const llmsFull = path.join(ctx.outDir, 'llms-full.txt');
+    await fs.promises.writeFile(llmsFull, corpus.join('\n'), 'utf8');
+  }
+});
diff --git a/docs/.vuepress/plugins/md-companions/strip.js b/docs/.vuepress/plugins/md-companions/strip.js
new file mode 100644
index 0000000000..f6036576fe
--- /dev/null
+++ b/docs/.vuepress/plugins/md-companions/strip.js
@@ -0,0 +1,75 @@
+/**
+ * Strips VuePress-specific markdown syntax, producing clean markdown
+ * suitable for LLM consumption. Fence-aware: never edits inside code blocks.
+ * @param {string} src raw markdown (frontmatter already removed)
+ * @returns {string} cleaned markdown
+ */
+function stripVuePressSyntax(src) {
+  const lines = src.split('\n');
+  const out = [];
+  let inFence = false;
+  let fenceMarker = '';
+  let inScript = false;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+
+    const fenceMatch = trimmed.match(/^(```+|~~~+)/);
+    if (fenceMatch && !inScript) {
+      if (!inFence) {
+        inFence = true;
+        fenceMarker = fenceMatch[1];   // full marker e.g. "```" or "````"
+      } else {
+        const closeMatch = trimmed.match(/^(```+|~~~+)/);
+        if (closeMatch && closeMatch[1][0] === fenceMarker[0] && closeMatch[1].length >= fenceMarker.length) {
+          inFence = false;
+        }
+      }
+      out.push(line);
+      continue;
+    }
+    if (inFence) {
+      out.push(line);
+      continue;
+    }
+
+    if (/^<(script|style)[\s>]/i.test(trimmed)) { inScript = true; continue; }
+    if (inScript) {
+      if (/<\/(script|style)>/i.test(trimmed)) inScript = false;
+      continue;
+    }
+
+    if (/^<[A-Z][A-Za-z0-9]*(\s[^>]*)?\/?>$/.test(trimmed)) continue;
+
+    if (/^\[\[toc\]\]$/i.test(trimmed)) continue;
+
+    const open = trimmed.match(/^:::\s*(\w+)\s*(.*)$/i);
+    if (open) {
+      const type = open[1].toLowerCase();
+      const title = open[2].trim();
+      const body = [];
+      i++;
+      const bodyStart = i;
+      while (i < lines.length && lines[i].trim() !== ':::') { body.push(lines[i]); i++; }
+      // If we hit EOF without finding closing :::, emit verbatim (not a real container).
+      if (i >= lines.length) {
+        out.push(lines[bodyStart - 1]); // re-emit the opening line
+        body.forEach(b => out.push(b));
+        continue;
+      }
+      // Demo/example containers (live code runners) are not prose — omit entirely.
+      if (type === 'example') { continue; }
+      if (title) { out.push(`> **${title}**`); out.push('>'); }
+      body.forEach(b => out.push(b.trim() === '' ? '>' : `> ${b}`));
+      while (out.length && out[out.length - 1] === '>') out.pop();
+      continue;
+    }
+
+    out.push(line);
+  }
+
+  return out.join('\n').replace(/\n{3,}/g, '\n\n').trim();
+}
+
+module.exports = { stripVuePressSyntax };
diff --git a/docs/.vuepress/public/llms.txt b/docs/.vuepress/public/llms.txt
new file mode 100644
index 0000000000..16bdfd167d
--- /dev/null
+++ b/docs/.vuepress/public/llms.txt
@@ -0,0 +1,10 @@
+# HyperFormula
+
+> HyperFormula is an open-source, high-performance calculation engine for spreadsheets and web applications.
+
+## Docs
+
+- Guide: https://hyperformula.handsontable.com/docs/guide/
+- API reference: https://hyperformula.handsontable.com/docs/api/
+- Full corpus: https://hyperformula.handsontable.com/docs/llms-full.txt
+- Official Claude skill: https://github.com/handsontable/handsontable-skills
diff --git a/docs/.vuepress/public/robots.txt b/docs/.vuepress/public/robots.txt
index ef083139b3..8ac6ab69c4 100644
--- a/docs/.vuepress/public/robots.txt
+++ b/docs/.vuepress/public/robots.txt
@@ -2,3 +2,6 @@ User-agent: *
 Allow: /
 
 Sitemap: https://hyperformula.handsontable.com/sitemap.xml
+
+# AI/LLM agent index
+# Full documentation corpus: https://hyperformula.handsontable.com/docs/llms-full.txt
diff --git a/docs/guide/setup-coding-agent.md b/docs/guide/setup-coding-agent.md
new file mode 100644
index 0000000000..889a5466a2
--- /dev/null
+++ b/docs/guide/setup-coding-agent.md
@@ -0,0 +1,45 @@
+# Set up your coding agent
+
+HyperFormula ships an official Claude skill and machine-readable docs so your AI coding agent can scaffold, configure, and debug HyperFormula correctly. Pick your tool below, or use the interactive wizard.
+
+<CodingAgentWizard />
+
+## Claude Code
+
+Install the official skill from the plugin marketplace:
+
+```
+/plugin marketplace add handsontable/handsontable-skills
+/plugin install handsontable-skills@handsontable-skills
+```
+
+Claude Code loads the `hyperformula` skill automatically based on what you ask.
+
+## Cursor, Copilot & other agents
+
+These tools don't yet support the Claude skill format. Point your agent at the machine-readable docs instead:
+
+- **Full corpus:** [`llms-full.txt`](../llms-full.txt) — the entire documentation in one LLM-friendly file.
+- **Per-page Markdown:** append `.md` to any docs URL, or use the **Copy Markdown** button on any page.
+
+For agents that read a rules file (e.g. Cursor's `AGENTS.md`), add a line pointing at the corpus URL so the agent fetches authoritative docs on demand.
+
+## Live docs via MCP (any agent)
+
+Two zero-setup ways to let an agent pull authoritative HyperFormula docs on demand — both read this site's `llms.txt`:
+
+- **GitMCP** — add the MCP server `https://gitmcp.io/handsontable/hyperformula` to your agent (e.g. `claude mcp add --transport http hyperformula https://gitmcp.io/handsontable/hyperformula`). No install, no auth.
+- **Context7** — run `npx -y @upstash/context7-mcp` (or use the Context7 skill / `ctx7` CLI) and ask for the `hyperformula` library. Context7 indexes this site's `llms.txt` / `llms-full.txt` (see `context7.json` in the repo root).
+
+## Manual install (any Claude Code setup)
+
+```bash
+git clone https://github.com/handsontable/handsontable-skills.git
+cp -r handsontable-skills/skills/hyperformula ~/.claude/skills/
+```
+
+## Resources
+
+- [Official skill repository](https://github.com/handsontable/handsontable-skills)
+- [`llms-full.txt`](../llms-full.txt)
+- [API reference](/api/)
diff --git a/docs/superpowers/plans/2026-05-31-hf154-agent-friendly-docs.md b/docs/superpowers/plans/2026-05-31-hf154-agent-friendly-docs.md
new file mode 100644
index 0000000000..bce12c9cc5
--- /dev/null
+++ b/docs/superpowers/plans/2026-05-31-hf154-agent-friendly-docs.md
@@ -0,0 +1,644 @@
+# HF-154 Agent-Friendly Docs Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Make HyperFormula's VuePress docs agent-friendly by emitting clean `.md` companions + `llms-full.txt`, adding a Copy Markdown button, and a "Set up your coding agent" page (static + interactive wizard).
+
+**Architecture:** Five components targeting VuePress 1.x under `docs/`. A post-build plugin (`generated` hook) writes `.md` companions and `llms-full.txt` into the dist dir. A global Vue component renders the Copy Markdown button using `$page.path`. A new guide page hosts both a static IDE matrix and an interactive wizard component. All paths respect `base: '/docs/'`.
+
+**Tech Stack:** VuePress 1.9.10, Vue 2 SFCs, markdown-it, Node.js fs, plain `node` test scripts (matching existing `docs/.vuepress/plugins/*/test.js` pattern).
+
+**Critical constraint:** `docs/.vuepress/build.config.js` sets `base: '/docs/'`, `dest: 'docs/.vuepress/dist/docs'`. `ctx.outDir` already includes the `/docs` segment. Page paths (`$page.path`) do NOT include base — prepend with `$withBase`.
+
+**Parallelization units** (for subagent dispatch):
+- **Unit A** = Task 1 (C1 plugin) — independent
+- **Unit B** = Task 2 (C2 button) — independent
+- **Unit C** = Tasks 3+4 (C3 page + C4 wizard, coupled, same page) — independent
+- **Unit D** = Task 5 (C5 llms.txt/robots.txt) — independent
+- **Task 6** = integration (wire into config.js, full build, verify) — runs LAST, after A–D merge
+
+---
+
+## Task 1: C1 — `md-companions` VuePress plugin
+
+**Files:**
+- Create: `docs/.vuepress/plugins/md-companions/strip.js` (pure stripping function)
+- Create: `docs/.vuepress/plugins/md-companions/strip.test.js` (node test)
+- Create: `docs/.vuepress/plugins/md-companions/index.js` (plugin: generated hook)
+- Create: `docs/.vuepress/plugins/md-companions/fixture.md` (test fixture)
+
+- [ ] **Step 1: Write the failing test for `stripVuePressSyntax`**
+
+Create `docs/.vuepress/plugins/md-companions/strip.test.js`:
+
+```js
+const assert = require('assert');
+const { stripVuePressSyntax } = require('./strip');
+
+let passed = 0;
+const check = (name, actual, expected) => {
+  assert.strictEqual(actual, expected, `FAIL: ${name}\n  expected: ${JSON.stringify(expected)}\n  actual:   ${JSON.stringify(actual)}`);
+  passed++;
+};
+
+// 1. :::tip container -> blockquote, body kept
+check('tip container',
+  stripVuePressSyntax(':::tip Heads up\nBe careful here.\n:::'),
+  '> **Heads up**\n>\n> Be careful here.');
+
+// 2. :::warning without title
+check('warning no title',
+  stripVuePressSyntax(':::warning\nDanger zone.\n:::'),
+  '> Danger zone.');
+
+// 3. CRITICAL: ::: inside a fenced code block is NOT touched
+check('code fence with ::: inside',
+  stripVuePressSyntax('```js\nconst x = ":::tip";\n```'),
+  '```js\nconst x = ":::tip";\n```');
+
+// 4. <script> block removed entirely
+check('script removed',
+  stripVuePressSyntax('Text before\n<script>\nconsole.log(1)\n</script>\nText after'),
+  'Text before\nText after');
+
+// 5. standalone Vue component removed
+check('vue component removed',
+  stripVuePressSyntax('Intro\n<CodingAgentWizard />\nOutro'),
+  'Intro\nOutro');
+
+// 6. [[toc]] removed
+check('toc removed',
+  stripVuePressSyntax('# Title\n[[toc]]\nBody'),
+  '# Title\nBody');
+
+// 7. headings, code, links, tables preserved
+check('content preserved',
+  stripVuePressSyntax('# H\n\n`code`\n\n[link](/guide/x)\n\n| a | b |\n|---|---|'),
+  '# H\n\n`code`\n\n[link](/guide/x)\n\n| a | b |\n|---|---|');
+
+console.log(`PASS md-companions/strip (${passed} assertions)`);
+```
+
+- [ ] **Step 2: Run test to verify it fails**
+
+Run: `node docs/.vuepress/plugins/md-companions/strip.test.js`
+Expected: FAIL — `Cannot find module './strip'`
+
+- [ ] **Step 3: Implement `strip.js`**
+
+Create `docs/.vuepress/plugins/md-companions/strip.js`:
+
+```js
+/**
+ * Strips VuePress-specific markdown syntax, producing clean markdown
+ * suitable for LLM consumption. Fence-aware: never edits inside code blocks.
+ * @param {string} src raw markdown (frontmatter already removed)
+ * @returns {string} cleaned markdown
+ */
+function stripVuePressSyntax(src) {
+  const lines = src.split('\n');
+  const out = [];
+  let inFence = false;
+  let fenceMarker = '';
+  let inScript = false;
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+
+    // Track fenced code blocks (``` or ~~~). Inside a fence, copy verbatim.
+    const fenceMatch = trimmed.match(/^(```+|~~~+)/);
+    if (fenceMatch && !inScript) {
+      if (!inFence) {
+        inFence = true;
+        fenceMarker = fenceMatch[1][0];
+      } else if (trimmed.startsWith(fenceMarker)) {
+        inFence = false;
+      }
+      out.push(line);
+      continue;
+    }
+    if (inFence) {
+      out.push(line);
+      continue;
+    }
+
+    // Remove <script> / <style> blocks entirely.
+    if (/^<(script|style)[\s>]/i.test(trimmed)) { inScript = true; continue; }
+    if (inScript) {
+      if (/<\/(script|style)>/i.test(trimmed)) inScript = false;
+      continue;
+    }
+
+    // Remove standalone Vue component tags (e.g. <CodingAgentWizard />).
+    if (/^<[A-Z][A-Za-z0-9]*(\s[^>]*)?\/?>$/.test(trimmed)) continue;
+
+    // Remove [[toc]].
+    if (/^\[\[toc\]\]$/i.test(trimmed)) continue;
+
+    // Convert custom container opening :::type [title].
+    const open = trimmed.match(/^:::\s*(tip|warning|danger|details)\s*(.*)$/i);
+    if (open) {
+      const title = open[2].trim();
+      // collect body until closing :::
+      const body = [];
+      i++;
+      while (i < lines.length && lines[i].trim() !== ':::') { body.push(lines[i]); i++; }
+      if (title) { out.push(`> **${title}**`); out.push('>'); }
+      body.forEach(b => out.push(b.trim() === '' ? '>' : `> ${b}`));
+      // trim a single trailing '>' artifact
+      while (out.length && out[out.length - 1] === '>') out.pop();
+      continue;
+    }
+
+    out.push(line);
+  }
+
+  return out.join('\n').replace(/\n{3,}/g, '\n\n').trim();
+}
+
+module.exports = { stripVuePressSyntax };
+```
+
+- [ ] **Step 4: Run test to verify it passes**
+
+Run: `node docs/.vuepress/plugins/md-companions/strip.test.js`
+Expected: `PASS md-companions/strip (7 assertions)`
+
+- [ ] **Step 5: Write the plugin `index.js`**
+
+Create `docs/.vuepress/plugins/md-companions/index.js`:
+
+```js
+const fs = require('fs');
+const path = require('path');
+const { stripVuePressSyntax } = require('./strip');
+
+/**
+ * VuePress plugin: after build, write a clean `.md` companion next to each
+ * rendered `.html`, plus an aggregate `llms-full.txt`. Respects ctx.outDir
+ * (which already includes the configured base segment).
+ * @param {object} options plugin options
+ * @param {object} ctx VuePress app context
+ */
+module.exports = (options, ctx) => ({
+  name: 'md-companions',
+  async generated() {
+    const hostname = (options && options.hostname) || 'https://hyperformula.handsontable.com';
+    const base = ctx.base || '/';
+    const pages = ctx.pages.filter(p => /\.html$/.test(p.path) && p.path !== '/404.html');
+    const corpus = [
+      '# HyperFormula Documentation',
+      '',
+      '> Full documentation corpus for LLM consumption.',
+      '> Individual pages also available at <base>/guide/<slug>.md',
+      '',
+    ];
+
+    for (const page of pages) {
+      const clean = stripVuePressSyntax(page._strippedContent || '');
+      const relPath = page.path.replace(/\.html$/, '.md');           // /guide/foo.md
+      const outFile = path.join(ctx.outDir, relPath.replace(/^\//, ''));
+      await fs.promises.mkdir(path.dirname(outFile), { recursive: true });
+      await fs.promises.writeFile(outFile, clean, 'utf8');
+
+      const url = hostname + base.replace(/\/$/, '') + page.path.replace(/\.html$/, '');
+      corpus.push('---', '', `## ${page.title || page.path}`, '', `URL: ${url}`, '', clean, '');
+    }
+
+    const llmsFull = path.join(ctx.outDir, 'llms-full.txt');
+    await fs.promises.writeFile(llmsFull, corpus.join('\n'), 'utf8');
+  }
+});
+```
+
+- [ ] **Step 6: Commit**
+
+```bash
+git add docs/.vuepress/plugins/md-companions/
+git commit -m "feat(docs): add md-companions plugin for .md exports and llms-full.txt"
+```
+
+---
+
+## Task 2: C2 — `CopyMarkdownButton.vue`
+
+**Files:**
+- Create: `docs/.vuepress/components/CopyMarkdownButton.vue`
+
+VuePress auto-registers any `.vue` file under `docs/.vuepress/components/` as a global component (no manual registration needed). It is rendered globally via `globalUIComponents` in Task 6.
+
+- [ ] **Step 1: Create the component**
+
+Create `docs/.vuepress/components/CopyMarkdownButton.vue`:
+
+```vue
+<template>
+  <button
+    v-if="mdUrl"
+    class="copy-md-button"
+    type="button"
+    :title="'Copy this page as Markdown URL for LLMs'"
+    @click="copy"
+  >{{ label }}</button>
+</template>
+
+<script>
+export default {
+  name: 'CopyMarkdownButton',
+  data() {
+    return { copied: false };
+  },
+  computed: {
+    // Build the served .md URL from the canonical page path + base.
+    // Homepage / index pages have no .html slug -> hide the button.
+    mdUrl() {
+      const p = this.$page && this.$page.path;
+      if (!p || !/\.html$/.test(p)) return null;
+      return this.$withBase(p.replace(/\.html$/, '.md'));
+    },
+    label() {
+      return this.copied ? 'Copied!' : 'Copy Markdown';
+    },
+  },
+  methods: {
+    copy() {
+      const absolute = window.location.origin + this.mdUrl;
+      navigator.clipboard.writeText(absolute).then(() => {
+        this.copied = true;
+        setTimeout(() => { this.copied = false; }, 1500);
+      });
+    },
+  },
+};
+</script>
+
+<style scoped>
+.copy-md-button {
+  position: fixed;
+  bottom: 1.5rem;
+  right: 1.5rem;
+  z-index: 100;
+  padding: 0.5rem 0.9rem;
+  font-size: 0.85rem;
+  border: 1px solid #3eaf7c;
+  border-radius: 4px;
+  background: #fff;
+  color: #3eaf7c;
+  cursor: pointer;
+  box-shadow: 0 1px 4px rgba(0,0,0,0.12);
+}
+.copy-md-button:hover { background: #3eaf7c; color: #fff; }
+</style>
+```
+
+- [ ] **Step 2: Verify it parses (lint)**
+
+Run: `npx eslint docs/.vuepress/components/CopyMarkdownButton.vue --no-eslintrc --parser vue-eslint-parser 2>/dev/null || echo "manual review: confirm template/script/style blocks well-formed"`
+Expected: no parse error (or fall back to manual confirmation — the project's ESLint targets `.js,.ts`, not `.vue`).
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add docs/.vuepress/components/CopyMarkdownButton.vue
+git commit -m "feat(docs): add Copy Markdown button global component"
+```
+
+---
+
+## Task 3: C3 — `setup-coding-agent.md` static page
+
+**Files:**
+- Create: `docs/guide/setup-coding-agent.md`
+
+**Install-command source of truth:** `handsontable/handsontable-skills` README. Verified real commands:
+- Claude Code marketplace: `/plugin marketplace add handsontable/handsontable-skills` then `/plugin install handsontable-skills@handsontable-skills`
+- Manual: `git clone https://github.com/handsontable/handsontable-skills.git` then `cp -r handsontable-skills/skills/hyperformula ~/.claude/skills/`
+- Cowork/web: zip from GitHub releases
+- API: folder upload
+
+The published skill has **no Cursor- or Copilot-specific installer**. Do NOT invent one. Cursor/Copilot/Other sections point to `llms-full.txt` + the manual clone, framed honestly.
+
+- [ ] **Step 1: Write the page**
+
+Create `docs/guide/setup-coding-agent.md`:
+
+```markdown
+# Set up your coding agent
+
+HyperFormula ships an official Claude skill and machine-readable docs so your AI coding agent can scaffold, configure, and debug HyperFormula correctly. Pick your tool below, or use the interactive wizard.
+
+<CodingAgentWizard />
+
+## Claude Code
+
+Install the official skill from the plugin marketplace:
+
+\```
+/plugin marketplace add handsontable/handsontable-skills
+/plugin install handsontable-skills@handsontable-skills
+\```
+
+Claude Code loads the `hyperformula` skill automatically based on what you ask.
+
+## Cursor, Copilot & other agents
+
+These tools don't yet support the Claude skill format. Point your agent at the machine-readable docs instead:
+
+- **Full corpus:** [`/docs/llms-full.txt`](/llms-full.txt) — the entire documentation in one LLM-friendly file.
+- **Per-page Markdown:** append `.md` to any docs URL, or use the **Copy Markdown** button on any page.
+
+For agents that read a rules file (e.g. Cursor's `AGENTS.md`), add a line pointing at the corpus URL so the agent fetches authoritative docs on demand.
+
+## Manual install (any Claude Code setup)
+
+\```bash
+git clone https://github.com/handsontable/handsontable-skills.git
+cp -r handsontable-skills/skills/hyperformula ~/.claude/skills/
+\```
+
+## Resources
+
+- [Official skill repository](https://github.com/handsontable/handsontable-skills)
+- [`llms-full.txt`](/llms-full.txt)
+- [API reference](/api/)
+```
+
+(Note: the `\``` fences above are escaped only in this plan; write real triple-backtick fences in the file.)
+
+- [ ] **Step 2: Verify links resolve under base**
+
+Run: `grep -n "llms-full.txt\|handsontable-skills" docs/guide/setup-coding-agent.md`
+Expected: links present. `$withBase` is applied by VuePress to root-absolute links like `/llms-full.txt` automatically in rendered output.
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add docs/guide/setup-coding-agent.md
+git commit -m "docs: add Set up your coding agent guide page"
+```
+
+---
+
+## Task 4: C4 — `CodingAgentWizard.vue` interactive component
+
+**Files:**
+- Create: `docs/.vuepress/components/CodingAgentWizard.vue`
+
+Embedded in the Task 3 page via `<CodingAgentWizard />`. Local Vue state only. Content per IDE mirrors the verified commands from Task 3 — no invented commands.
+
+- [ ] **Step 1: Create the component**
+
+Create `docs/.vuepress/components/CodingAgentWizard.vue`:
+
+```vue
+<template>
+  <div class="agent-wizard">
+    <div v-if="!selected" class="agent-wizard__choices">
+      <p class="agent-wizard__prompt">Which coding agent do you use?</p>
+      <button
+        v-for="opt in options"
+        :key="opt.id"
+        class="agent-wizard__choice"
+        type="button"
+        @click="selected = opt.id"
+      >{{ opt.label }}</button>
+    </div>
+
+    <div v-else class="agent-wizard__result">
+      <button class="agent-wizard__back" type="button" @click="reset">&larr; Change</button>
+      <h3>{{ current.label }}</h3>
+      <pre class="agent-wizard__snippet"><code>{{ current.snippet }}</code></pre>
+      <button class="agent-wizard__copy" type="button" @click="copy">{{ copied ? 'Copied!' : 'Copy' }}</button>
+      <p class="agent-wizard__note" v-html="current.note"></p>
+    </div>
+  </div>
+</template>
+
+<script>
+export default {
+  name: 'CodingAgentWizard',
+  data() {
+    return {
+      selected: null,
+      copied: false,
+      options: [
+        {
+          id: 'claude-code',
+          label: 'Claude Code',
+          snippet: '/plugin marketplace add handsontable/handsontable-skills\n/plugin install handsontable-skills@handsontable-skills',
+          note: 'Installs the official <code>hyperformula</code> skill. Claude Code loads it automatically.',
+        },
+        {
+          id: 'cursor',
+          label: 'Cursor',
+          snippet: 'Add to your AGENTS.md / rules file:\nHyperFormula docs (LLM-friendly): https://hyperformula.handsontable.com/docs/llms-full.txt',
+          note: 'Cursor has no Claude-skill installer yet — point it at the full docs corpus instead.',
+        },
+        {
+          id: 'copilot',
+          label: 'GitHub Copilot',
+          snippet: 'Add to .github/copilot-instructions.md:\nReference HyperFormula docs: https://hyperformula.handsontable.com/docs/llms-full.txt',
+          note: 'Copilot reads an instructions file — link it to the corpus so it fetches authoritative docs.',
+        },
+        {
+          id: 'other',
+          label: 'Other / API',
+          snippet: 'curl -s https://hyperformula.handsontable.com/docs/llms-full.txt',
+          note: 'Fetch the full corpus, or upload the skill folder from <code>handsontable/handsontable-skills</code> to the Claude API.',
+        },
+      ],
+    };
+  },
+  computed: {
+    current() {
+      return this.options.find(o => o.id === this.selected) || null;
+    },
+  },
+  methods: {
+    reset() { this.selected = null; this.copied = false; },
+    copy() {
+      navigator.clipboard.writeText(this.current.snippet).then(() => {
+        this.copied = true;
+        setTimeout(() => { this.copied = false; }, 1500);
+      });
+    },
+  },
+};
+</script>
+
+<style scoped>
+.agent-wizard { border: 1px solid #eaecef; border-radius: 6px; padding: 1rem 1.25rem; margin: 1.5rem 0; }
+.agent-wizard__prompt { font-weight: 600; margin: 0 0 0.75rem; }
+.agent-wizard__choice,
+.agent-wizard__copy,
+.agent-wizard__back {
+  cursor: pointer; border: 1px solid #3eaf7c; background: #fff; color: #3eaf7c;
+  border-radius: 4px; padding: 0.4rem 0.8rem; margin: 0 0.5rem 0.5rem 0; font-size: 0.9rem;
+}
+.agent-wizard__choice:hover,
+.agent-wizard__copy:hover { background: #3eaf7c; color: #fff; }
+.agent-wizard__back { border-color: #ccc; color: #666; }
+.agent-wizard__snippet { background: #f6f6f6; padding: 0.75rem; border-radius: 4px; overflow-x: auto; }
+.agent-wizard__note { font-size: 0.85rem; color: #666; }
+</style>
+```
+
+- [ ] **Step 2: Verify wizard snippets match Task 3 verified commands**
+
+Run: `grep -c "handsontable/handsontable-skills" docs/.vuepress/components/CodingAgentWizard.vue`
+Expected: `>= 2` (Claude Code marketplace + Other/API reference). Confirm NO command absent from the published skill README appears.
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add docs/.vuepress/components/CodingAgentWizard.vue
+git commit -m "feat(docs): add interactive coding-agent setup wizard"
+```
+
+---
+
+## Task 5: C5 — `llms.txt` + `robots.txt`
+
+**Files:**
+- Create: `docs/.vuepress/public/llms.txt`
+- Modify: `docs/.vuepress/public/robots.txt`
+
+Files in `docs/.vuepress/public/` are copied verbatim to the dist root (under base `/docs/`). So `llms.txt` lands at `/docs/llms.txt`.
+
+- [ ] **Step 1: Create `llms.txt`**
+
+Create `docs/.vuepress/public/llms.txt`:
+
+```
+# HyperFormula
+
+> HyperFormula is an open-source, high-performance calculation engine for spreadsheets and web applications.
+
+## Docs
+
+- Guide: https://hyperformula.handsontable.com/docs/guide/
+- API reference: https://hyperformula.handsontable.com/docs/api/
+- Full corpus: https://hyperformula.handsontable.com/docs/llms-full.txt
+- Official Claude skill: https://github.com/handsontable/handsontable-skills
+```
+
+- [ ] **Step 2: Append corpus pointer to `robots.txt`**
+
+Current `docs/.vuepress/public/robots.txt`:
+
+```
+User-agent: *
+Allow: /
+
+Sitemap: https://hyperformula.handsontable.com/sitemap.xml
+```
+
+Add at the end:
+
+```
+# AI/LLM agent index
+# Full documentation corpus: https://hyperformula.handsontable.com/docs/llms-full.txt
+```
+
+- [ ] **Step 3: Verify files**
+
+Run: `cat docs/.vuepress/public/llms.txt && echo "---" && tail -3 docs/.vuepress/public/robots.txt`
+Expected: both show the corpus URL `.../docs/llms-full.txt`.
+
+- [ ] **Step 4: Commit**
+
+```bash
+git add docs/.vuepress/public/llms.txt docs/.vuepress/public/robots.txt
+git commit -m "docs: add llms.txt and link llms-full.txt from robots.txt"
+```
+
+---
+
+## Task 6: Integration — wire into `config.js` and verify build
+
+**Files:**
+- Modify: `docs/.vuepress/config.js` (require plugin, register in `plugins`, add `globalUIComponents`, add sidebar entry)
+
+Runs AFTER Tasks 1–5 are merged.
+
+- [ ] **Step 1: Require the plugin at top of `config.js`**
+
+Add after the existing `includeCodeSnippet` require (around line 7):
+
+```js
+const mdCompanions = require('./plugins/md-companions');
+```
+
+- [ ] **Step 2: Register the plugin in the `plugins` array**
+
+In the `plugins: [` array (after the sitemap entry), add:
+
+```js
+[mdCompanions, { hostname: DOCS_HOSTNAME }],
+```
+
+- [ ] **Step 3: Register the global button component**
+
+Change line 34 from `globalUIComponents: [],` to:
+
+```js
+globalUIComponents: ['CopyMarkdownButton'],
+```
+
+- [ ] **Step 4: Add sidebar entry for the new page**
+
+In `themeConfig.sidebar['/']`, inside the `Getting started` group's `children` array, add after the `license-key` entry:
+
+```js
+['/guide/setup-coding-agent', 'Set up your coding agent'],
+```
+
+- [ ] **Step 5: Run the full docs build**
+
+Run: `npm run docs:build 2>&1 | tail -20`
+Expected: build succeeds, "Generated static files in ...".
+
+- [ ] **Step 6: Verify companion + corpus output exists**
+
+Run:
+```bash
+ls docs/.vuepress/dist/docs/guide/basic-usage.md docs/.vuepress/dist/docs/llms-full.txt docs/.vuepress/dist/docs/llms.txt
+echo "--- companion is clean markdown (no <script>, no :::) ---"
+grep -c ":::" docs/.vuepress/dist/docs/guide/basic-usage.md || true
+```
+Expected: all three files exist; companion has no `:::` container fences.
+
+- [ ] **Step 7: Verify the button URL resolves (no 404)**
+
+Run:
+```bash
+# the page's .md companion must exist at the path the button computes
+test -f docs/.vuepress/dist/docs/guide/setup-coding-agent.md && echo "button target OK"
+```
+Expected: `button target OK`.
+
+- [ ] **Step 8: Lint**
+
+Run: `npm run lint 2>&1 | tail -5`
+Expected: exit 0 (config.js is the only linted file touched).
+
+- [ ] **Step 9: Commit**
+
+```bash
+git add docs/.vuepress/config.js
+git commit -m "feat(docs): wire md-companions plugin, Copy Markdown button, and setup page"
+```
+
+---
+
+## Acceptance Criteria
+
+- [ ] `.md` companion generated for every guide/api page under `dist/docs/`
+- [ ] `llms-full.txt` aggregates all pages with absolute URLs (under `/docs/`)
+- [ ] Copy Markdown button appears on content pages, hidden on homepage, copies correct `.md` URL
+- [ ] `setup-coding-agent.md` reachable from sidebar; all install commands traceable to `handsontable/handsontable-skills` README — zero invented commands
+- [ ] Interactive wizard renders, IDE selection shows verified snippet, copy works
+- [ ] `llms.txt` + `robots.txt` point at `/docs/llms-full.txt`
+- [ ] Code-fence-with-`:::` fixture test passes (no false stripping)
+- [ ] Full `npm run docs:build` succeeds; `npm run lint` exit 0
diff --git a/docs/superpowers/specs/2026-05-31-hf154-agent-friendly-docs-design.md b/docs/superpowers/specs/2026-05-31-hf154-agent-friendly-docs-design.md
new file mode 100644
index 0000000000..dff9a02cdc
--- /dev/null
+++ b/docs/superpowers/specs/2026-05-31-hf154-agent-friendly-docs-design.md
@@ -0,0 +1,195 @@
+# HF-154: Agent-Friendly Docs — Design Spec
+
+**Date:** 2026-05-31
+**Status:** Approved (meeting 2026-05-28, Marcin + Kuba)
+**Branch target:** develop
+
+## Context
+
+Joseph (GreenFlux) already shipped in `hyperformula-website` repo: robots.txt, sitemap, llms.txt, public HF skill, Git MCP. He also has DRAFT PR #1686 migrating VuePress → Astro Starlight with `starlight-page-actions` (auto `.md` companions + Copy Markdown button). We stay on VuePress for this release and implement equivalent functionality, borrowing Joseph's UX patterns where useful.
+
+## Scope
+
+Five independent components, all targeted at VuePress 1.x under `docs/`.
+
+## Critical integration constraint: base path
+
+`docs/.vuepress/build.config.js` sets `base: '/docs/'` and `dest: 'docs/.vuepress/dist/docs'`. The HF docs site is served under `/docs/`, not domain root. Every component MUST respect this:
+
+- **C1** writes companions next to the rendered `.html` inside `ctx.outDir` (which already includes the `/docs` segment) — derive paths from `ctx`, never hardcode `dist/guide/`.
+- **C2** computes the `.md` URL from `this.$page.path` (VuePress canonical path) + `ctx.base`, never from naive `window.location` string munging.
+- **C5** `llms-full.txt` is emitted under the same base. The robots.txt pointer and any absolute URLs must use `${DOCS_HOSTNAME}${base}llms-full.txt` (i.e. `.../docs/llms-full.txt`), not domain root. Confirm whether Netlify rewrites `/llms-full.txt` → `/docs/llms-full.txt`; if not, the canonical location is under `/docs/`.
+
+Verified against VuePress core: `generated` hook exists (async, receives `pagePaths`) — `@vuepress/core/lib/node/plugin-api/constants.js:8`, `build/index.js:111`. Output files are flat `<slug>.html` — `build/index.js:165`. `globalUIComponents` is a real plugin option.
+
+---
+
+## C1: `vuepress-plugin-md-companions`
+
+**What it does:** Post-build VuePress plugin. For every guide page source file, strips VuePress-specific syntax and emits a clean `.md` companion file into `dist/` alongside the `.html`. Also emits `dist/llms-full.txt`.
+
+**Source of content:** Use `ctx.pages[].​_strippedContent` (raw markdown with frontmatter already removed by VuePress) rather than re-reading files from disk. Each page object also exposes `.path`, `.title`, `.frontmatter`.
+
+**Strips from source markdown — token-aware, NOT naive regex:**
+- Custom containers (`:::tip`, `:::warning`, `:::danger`) → convert to blockquote, keep body text. Must skip fenced code regions (a code block may legitimately contain `:::`). Implement by tracking fence state line-by-line, or run through a markdown-it instance.
+- Inline `<script>`, `<style>` blocks → omit entirely
+- VuePress components (`<SomeComponent/>`) → omit
+- `[[toc]]` tokens → omit
+
+**Keeps:** headings, paragraphs, code blocks (fenced and indented), links (resolved to absolute URLs using `DOCS_HOSTNAME` + base), images, tables.
+
+**Output per page:** companion `.md` written next to the rendered `.html` inside `ctx.outDir`, e.g. `<outDir>/guide/<slug>.md`. Because `dest` already includes `/docs`, the served URL is `/docs/guide/<slug>.md`.
+
+**Required fixture test:** a page containing a fenced code block with `:::` inside it, plus a real `:::tip`, must produce correct output (code block untouched, tip converted). This is the acceptance test for the stripping logic.
+
+**llms-full.txt format:**
+```
+# HyperFormula Documentation
+
+> Full documentation corpus for LLM consumption.
+> Individual pages also available at /docs/guide/<slug>.md
+
+---
+
+## <Page Title>
+
+URL: https://hyperformula.handsontable.com/guide/<slug>
+
+<cleaned markdown content>
+
+---
+```
+
+**VuePress hook:** `generated(pagePaths)` lifecycle + Node.js fs to read source `.md` files from `docs/guide/` and `docs/api/` and write companions to `dist/`. `DOCS_HOSTNAME` defaults to `https://hyperformula.handsontable.com` (same env var used in `config.js`).
+
+**File:** `docs/.vuepress/plugins/md-companions/index.js`
+
+---
+
+## C2: `CopyMarkdownButton.vue`
+
+**What it does:** Global UI component (registered in `config.js` `globalUIComponents`) rendered on every page. Displays a "Copy Markdown" button. On click: constructs the `.md` URL for the current page, copies to clipboard, shows a brief "Copied!" flash.
+
+**URL construction (do NOT use `window.location`):** VuePress serves clean URLs (`/docs/guide/foo`, sometimes trailing slash, homepage `/docs/`). Naive string munging produces garbage like `/docs/.md`. Instead use `this.$page.path` (canonical regularPath, e.g. `/guide/foo.html`):
+- `/guide/foo.html` → `${base}guide/foo.md`
+- `/` or `/index.html` (homepage) → button hidden or links to `${base}llms-full.txt`
+- Prefix with `ctx.base` (`/docs/`) to get the served path.
+
+**Placement:** Fixed `position: fixed; bottom: 1.5rem; right: 1.5rem` — matches the intent of Joseph's sidebar button but works within VuePress default theme without theme overrides. CSS scoped to the component; z-index above content, below modals (z-index: 100).
+
+**File:** `docs/.vuepress/components/CopyMarkdownButton.vue`
+**Registration:** `globalUIComponents: ['CopyMarkdownButton']` in `config.js`
+
+---
+
+## C3: `setup-coding-agent.md` (Version A — static)
+
+**What it does:** New guide page at `docs/guide/setup-coding-agent.md`. Reachable from the sidebar. Covers how to set up a coding agent to work with HyperFormula.
+
+**Page structure:**
+```
+# Set Up Your Coding Agent for HyperFormula
+
+One-paragraph intro.
+
+## Claude Code
+install command + install prompt + what the skill enables
+
+## Cursor
+AGENTS.md / .cursorrules setup + link to skill
+
+## GitHub Copilot
+instructions file setup
+
+## Other agents
+Generic: point at llms-full.txt + AGENTS.md pattern
+
+## Resources
+Links: skill repo, llms-full.txt, AGENTS.md, llms.txt
+```
+
+**Sidebar:** Add entry to `docs/.vuepress/config.js` sidebar under the existing "Getting started" or a new "AI & Agents" group.
+
+**File:** `docs/guide/setup-coding-agent.md`
+
+---
+
+## C4: `CodingAgentWizard.vue` (Version B — interactive)
+
+**What it does:** Vue SFC embedded in `setup-coding-agent.md` via `<CodingAgentWizard />`. Step 1: card-based IDE selector. Step 2: rendered instructions with a "Copy prompt" button.
+
+**IDEs supported:** Claude Code, Cursor, GitHub Copilot, Other.
+
+**Step 2 content per IDE — install commands MUST be verified, not invented:**
+Do not write install commands from memory. Before implementing, read Joseph's published skill repo (the public HF skill) and copy its actual installation instructions verbatim. Claude Code installs skills via the plugin marketplace (`/plugin`), not a fabricated `/install hyperformula`. Each IDE section:
+- **Claude Code:** real marketplace/plugin install steps from the published skill README
+- **Cursor:** real `.cursorrules` / `AGENTS.md` snippet (verify Cursor's current mechanism)
+- **Copilot:** real GitHub Copilot instructions-file mechanism
+- **Other:** generic `llms-full.txt` fetch instruction (this one is safe — it's our own artifact)
+
+**Acceptance gate:** every command on this page must be traceable to the published skill or official IDE docs. No invented commands ship.
+
+**State:** Local Vue `data` (no Vuex). `selectedIde: null | string`, `copied: false`.
+
+**File:** `docs/.vuepress/components/CodingAgentWizard.vue`
+
+Both versions (A static + B wizard) live on the same page. Version A provides the fallback readable content; Version B is the progressive enhancement above it.
+
+---
+
+## C5: `llms.txt` and `robots.txt` update
+
+`docs/.vuepress/public/robots.txt` already exists and points to sitemap. Add `llms-full.txt` reference:
+
+Add a comment line pointing to the full corpus (robots.txt doesn't have a formal LLMs field, but a comment is discoverable):
+
+```
+# AI/LLM agent index
+# Full documentation corpus: https://hyperformula.handsontable.com/llms-full.txt
+```
+
+Also create `docs/.vuepress/public/llms.txt` if not present (Joseph added it to the website repo only; the main HF repo currently has none). Minimal format per the llms.txt standard:
+
+```
+# HyperFormula
+
+> HyperFormula is an open-source spreadsheet calculation engine.
+
+## Docs
+
+- Guide: https://hyperformula.handsontable.com/guide/
+- Full corpus: https://hyperformula.handsontable.com/llms-full.txt
+```
+
+---
+
+## Build pipeline impact
+
+```
+npm run docs:build
+  └─ vuepress build docs
+       └─ generated() hook fires
+            ├─ emits dist/guide/*.md
+            ├─ emits dist/api/*.md
+            └─ emits dist/llms-full.txt
+```
+
+No new npm scripts needed. Plugin self-registers via `config.js`.
+
+---
+
+## Reference: Joseph's approach (PR #1686)
+
+- `starlight-page-actions@^0.6.0` handles .md companions + button in Astro
+- Button placement: right sidebar under "On this page"
+- Also adds "Open in ChatGPT" and "Open in Claude" buttons — **not in our scope** for this PR, but the UX pattern is worth noting for a follow-up
+
+---
+
+## Out of scope
+
+- Migrating to Astro Starlight (Joseph's PR #1686 — separate track)
+- "Open in ChatGPT" / "Open in Claude" buttons (Joseph's PR)
+- Skill content updates (Joseph owns the published skill)
+- Testing whether the skill gives correct results (Ola's job)
+- Printing Press CLI evaluation (research backlog)
diff --git a/scripts/extract-public-api.js b/scripts/extract-public-api.js
new file mode 100644
index 0000000000..5ffd6bcc9b
--- /dev/null
+++ b/scripts/extract-public-api.js
@@ -0,0 +1,310 @@
+#!/usr/bin/env node
+/**
+ * Extracts the HyperFormula public API surface at a given git ref (or from
+ * the current working tree when --ref is omitted).
+ *
+ * Used by the prep-flip T2.5 tier (cross-repo contract check) to detect
+ * breaking changes between develop and a PR HEAD.
+ *
+ * Usage:
+ *   node extract-public-api.js [--ref <sha|branch>]
+ *
+ * Output (stdout): { exports: ApiExport[], lint_scope: string[] }
+ *
+ * @typedef {{ file: string, name: string, kind: string,
+ *             required_params: string[], optional_params: string[] }} ApiExport
+ * @typedef {{ exports: ApiExport[], lint_scope: string[] }} ApiSurface
+ */
+'use strict'
+
+const { execSync } = require('child_process')
+const fs = require('fs')
+const path = require('path')
+
+// ---------------------------------------------------------------------------
+// CLI args
+// ---------------------------------------------------------------------------
+
+const args = process.argv.slice(2)
+const refIdx = args.indexOf('--ref')
+/** @type {string|null} */
+const ref = refIdx !== -1 ? (args[refIdx + 1] ?? null) : null
+
+// ---------------------------------------------------------------------------
+// Source-reading helpers — git show at ref OR filesystem fallback
+// ---------------------------------------------------------------------------
+
+/**
+ * Read a repo-relative file either at the given git ref or from the working
+ * tree.  Returns null when the file cannot be found at either location.
+ *
+ * @param {string} repoRelPath  e.g. "src/index.ts"
+ * @returns {string|null} File contents, or null when the file is not found.
+ */
+function readFile(repoRelPath) {
+  if (ref) {
+    try {
+      return execSync(`git show "${ref}:${repoRelPath}"`, {
+        encoding: 'utf8',
+        stdio: ['pipe', 'pipe', 'pipe'],
+      })
+    } catch {
+      // Fall through to working-tree read below.
+    }
+  }
+  // Working-tree fallback: resolve relative to the repo root.
+  try {
+    const repoRoot = execSync('git rev-parse --show-toplevel', {
+      encoding: 'utf8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    }).trim()
+    const absPath = path.join(repoRoot, repoRelPath)
+    return fs.readFileSync(absPath, 'utf8')
+  } catch {
+    return null
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Parameter-list parsing helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Split a parameter-list string on top-level commas, respecting angle-bracket
+ * and parenthesis nesting for generic types like `Map<string, number>`.
+ *
+ * @param {string} str  Raw parameter-list text.
+ * @returns {string[]} Individual parameter strings (whitespace preserved).
+ */
+function splitParams(str) {
+  /** @type {string[]} */
+  const parts = []
+  let depth = 0
+  let current = ''
+  for (const ch of str) {
+    if ('<([{'.includes(ch)) depth += 1
+    else if ('>)]}' .includes(ch)) depth -= 1
+    else if (ch === ',' && depth === 0) {
+      parts.push(current)
+      current = ''
+      continue
+    }
+    current += ch
+  }
+  if (current.trim()) parts.push(current)
+  return parts
+}
+
+/**
+ * Parse a raw parameter string into required/optional name lists.
+ *
+ * @param {string|null|undefined} paramStr  Raw parameter-list string, or null/undefined for empty lists.
+ * @returns {{ required: string[], optional: string[] }} Parsed required and optional parameter name lists.
+ */
+function parseParams(paramStr) {
+  if (!paramStr || !paramStr.trim()) return { required: [], optional: [] }
+  const required = /** @type {string[]} */ ([])
+  const optional = /** @type {string[]} */ ([])
+  for (const raw of splitParams(paramStr)) {
+    const trimmed = raw.trim()
+    if (!trimmed) continue
+    // Strip TypeScript access modifiers (constructor injection pattern).
+    const clean = trimmed.replace(/^(private|public|protected|readonly|\s)+/, '')
+    // Extract parameter name (before `:`, `?`, `=`, or rest `...`).
+    const nameMatch = /^\.{3}?(\w+)/.exec(clean)
+    const paramName = nameMatch
+      ? nameMatch[1]
+      : (clean.split(/[?:=\s]/)[0] ?? '').trim()
+    if (!paramName) continue
+    // Optional when the name fragment contains `?` or a default `=` precedes `:`.
+    const beforeColon = clean.split(':')[0] ?? ''
+    const isOptional = beforeColon.includes('?') || beforeColon.includes('=')
+    if (isOptional) {
+      optional.push(paramName.replace('?', ''))
+    } else {
+      required.push(paramName)
+    }
+  }
+  return { required, optional }
+}
+
+// ---------------------------------------------------------------------------
+// src/index.ts — named export extraction
+// ---------------------------------------------------------------------------
+
+/**
+ * Extract all public exports from src/index.ts:
+ *   - `export { X, Y }` or `export { X, Y } from '...'`  → kind 'unknown'
+ *   - `export class X ...`                                 → kind 'class'
+ *   - `export function X(...)`                             → kind 'function'
+ *   - `export type/interface/enum X ...`                   → kind 'type'
+ *
+ * @param {string} src  Source text of src/index.ts.
+ * @returns {ApiExport[]} All named exports found in the file.
+ */
+function extractIndexExports(src) {
+  if (!src) return []
+  /** @type {ApiExport[]} */
+  const indexExports = []
+
+  // Named export blocks (with or without `from`), multiline-safe via [\s\S].
+  // Matches: export { A, B, C } [from '...']
+  const namedExportRe = /export\s*\{([\s\S]*?)\}(?:\s*from\s*['"][^'"]+['"])?/g
+  let m
+  while ((m = namedExportRe.exec(src)) !== null) {
+    const names = m[1]
+      .split(',')
+      .map(n => n.trim().replace(/\/\/[^\n]*/g, '').trim()) // strip inline comments
+      .map(n => n.split(/\s+as\s+/).pop()?.trim())
+      .filter(n => n && /^\w/.test(n))
+    for (const name of names) {
+      if (!indexExports.some(e => e.name === name)) {
+        indexExports.push({
+          file: 'src/index.ts',
+          name: /** @type {string} */ (name),
+          kind: 'unknown',
+          required_params: [],
+          optional_params: [],
+        })
+      }
+    }
+  }
+
+  // Direct exports: export class X / export function X(...) / export type X
+  const directClassRe = /export\s+(?:abstract\s+)?class\s+(\w+)/g
+  while ((m = directClassRe.exec(src)) !== null) {
+    const name = m[1]
+    if (!indexExports.some(e => e.name === name)) {
+      indexExports.push({ file: 'src/index.ts', name, kind: 'class', required_params: [], optional_params: [] })
+    }
+  }
+
+  const directFnRe = /export\s+(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)/g
+  while ((m = directFnRe.exec(src)) !== null) {
+    const name = m[1]
+    const params = parseParams(m[2])
+    if (!indexExports.some(e => e.name === name)) {
+      indexExports.push({
+        file: 'src/index.ts',
+        name,
+        kind: 'function',
+        required_params: params.required,
+        optional_params: params.optional,
+      })
+    }
+  }
+
+  const directTypeRe = /export\s+(?:type|interface|enum)\s+(\w+)/g
+  while ((m = directTypeRe.exec(src)) !== null) {
+    const name = m[1]
+    if (!indexExports.some(e => e.name === name)) {
+      indexExports.push({ file: 'src/index.ts', name, kind: 'type', required_params: [], optional_params: [] })
+    }
+  }
+
+  return indexExports
+}
+
+// ---------------------------------------------------------------------------
+// src/HyperFormula.ts — public method + constructor extraction
+// ---------------------------------------------------------------------------
+
+/**
+ * Extract the HyperFormula constructor signature and all public instance/static
+ * methods from src/HyperFormula.ts.
+ *
+ * @param {string|null} src  Source text of src/HyperFormula.ts, or null when unavailable.
+ * @returns {ApiExport[]} Constructor entry plus all public method entries.
+ */
+function extractHyperFormulaExports(src) {
+  if (!src) return []
+  /** @type {ApiExport[]} */
+  const exports = []
+
+  // Constructor
+  const ctorMatch = /\bconstructor\s*\(([^)]*)\)/.exec(src)
+  if (ctorMatch) {
+    const params = parseParams(ctorMatch[1])
+    exports.push({
+      file: 'src/HyperFormula.ts',
+      name: 'HyperFormula.constructor',
+      kind: 'constructor',
+      required_params: params.required,
+      optional_params: params.optional,
+    })
+  }
+
+  // Public (static) (async) (get|set) methodName(params)
+  const methodRe =
+    /(?:^|\n)[ \t]+public\s+(static\s+)?(async\s+)?(?:(?:get|set)\s+)?(\w[\w]*)\s*\(([^)]*)\)/g
+  let m
+  while ((m = methodRe.exec(src)) !== null) {
+    const name = m[3]
+    if (name === 'constructor') continue
+    if (name.startsWith('_')) continue // private-by-convention
+
+    const isStatic = !!m[1]
+    const params = parseParams(m[4])
+    exports.push({
+      file: 'src/HyperFormula.ts',
+      name: isStatic ? `HyperFormula.${name}` : `HyperFormula#${name}`,
+      kind: isStatic ? 'static-method' : 'method',
+      required_params: params.required,
+      optional_params: params.optional,
+    })
+  }
+
+  return exports
+}
+
+// ---------------------------------------------------------------------------
+// tsconfig.json — lint_scope extraction
+// ---------------------------------------------------------------------------
+
+/**
+ * Derive the lint scope from tsconfig.json `include` patterns.
+ * Returns an array of top-level directory prefixes, e.g. `['src', 'test']`.
+ *
+ * @returns {string[]} Top-level directory prefixes included by the TypeScript project.
+ */
+function extractLintScope() {
+  const tsconfigSrc = readFile('tsconfig.json')
+  if (!tsconfigSrc) return ['src']
+  try {
+    // tsconfig uses JSON5-ish syntax — strip single-line comments before parsing.
+    const stripped = tsconfigSrc.replace(/\/\/[^\n]*/g, '')
+    const tsconfig = JSON.parse(stripped)
+    const include = Array.isArray(tsconfig.include) ? tsconfig.include : ['src']
+    return include
+      .map(p =>
+        String(p)
+          .replace(/\/\*\*.*/, '')
+          .replace(/\/\*.*/, '')
+          .replace(/\/$/, ''),
+      )
+      .filter(p => p.length > 0)
+  } catch {
+    return ['src']
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+const indexSrc = readFile('src/index.ts')
+const hfSrc = readFile('src/HyperFormula.ts')
+
+/** @type {ApiExport[]} */
+const apiExports = [
+  ...extractIndexExports(indexSrc ?? ''),
+  ...extractHyperFormulaExports(hfSrc),
+]
+
+/** @type {string[]} */
+const lintScope = extractLintScope()
+
+/** @type {ApiSurface} */
+const result = { exports: apiExports, lint_scope: lintScope }
+
+process.stdout.write(JSON.stringify(result) + '\n')
diff --git a/test/docs/md-companions-strip.spec.js b/test/docs/md-companions-strip.spec.js
new file mode 100644
index 0000000000..b30eefa23b
--- /dev/null
+++ b/test/docs/md-companions-strip.spec.js
@@ -0,0 +1,58 @@
+/**
+ * CI-discoverable tests for the md-companions VuePress plugin's markdown
+ * stripper (HF-154, agent-friendly docs). The stripper turns VuePress-flavoured
+ * markdown into clean markdown for the per-page `.md` companions and `llms.txt`,
+ * so its fidelity is the acceptance gate for the feature.
+ *
+ * This is a `.js` spec under `test/` so Jest's testMatch (`test/**\/*spec.(ts|js)`)
+ * discovers it, while Karma (which only globs `.spec.ts`) skips it — the stripper
+ * is plain Node code that does not run in the browser bundle.
+ */
+const { stripVuePressSyntax } = require('../../docs/.vuepress/plugins/md-companions/strip')
+
+describe('md-companions stripVuePressSyntax', () => {
+  it('converts a tip container with a title to a blockquote', () => {
+    expect(stripVuePressSyntax(':::tip Heads up\nBe careful here.\n:::'))
+      .toBe('> **Heads up**\n>\n> Be careful here.')
+  })
+
+  it('converts a titleless warning container to a blockquote', () => {
+    expect(stripVuePressSyntax(':::warning\nDanger zone.\n:::'))
+      .toBe('> Danger zone.')
+  })
+
+  it('leaves ::: tokens inside a code fence untouched', () => {
+    expect(stripVuePressSyntax('```js\nconst x = ":::tip";\n```'))
+      .toBe('```js\nconst x = ":::tip";\n```')
+  })
+
+  it('removes <script> blocks', () => {
+    expect(stripVuePressSyntax('Text before\n<script>\nconsole.log(1)\n</script>\nText after'))
+      .toBe('Text before\nText after')
+  })
+
+  it('removes self-closing Vue components', () => {
+    expect(stripVuePressSyntax('Intro\n<CodingAgentWizard />\nOutro'))
+      .toBe('Intro\nOutro')
+  })
+
+  it('removes the [[toc]] marker', () => {
+    expect(stripVuePressSyntax('# Title\n[[toc]]\nBody'))
+      .toBe('# Title\nBody')
+  })
+
+  it('preserves plain markdown content', () => {
+    expect(stripVuePressSyntax('# H\n\n`code`\n\n[link](/guide/x)\n\n| a | b |\n|---|---|'))
+      .toBe('# H\n\n`code`\n\n[link](/guide/x)\n\n| a | b |\n|---|---|')
+  })
+
+  it('strips :::example (live demo) containers entirely', () => {
+    expect(stripVuePressSyntax('## Demo\n\n::: example #ex1 --html 1\n@[code](example.html)\n:::\n\nOutro'))
+      .toBe('## Demo\n\nOutro')
+  })
+
+  it('does not let an inner 3-backtick fence close a 4-backtick outer fence', () => {
+    expect(stripVuePressSyntax('````markdown\n```js\ncode\n```\n````'))
+      .toBe('````markdown\n```js\ncode\n```\n````')
+  })
+})