diff --git a/AGENTS.md b/AGENTS.md
index 6989bb4..ba869e1 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -12,6 +12,7 @@ wherefore/
   topics.md         controlled tag vocabulary: Areas and Topics
   log/YYYY-MM-DD-short-slug.md    one decision per file
   questions/Q-NNN.md              one question per file
+  plan/short-slug.md              forward-looking plans and roadmaps, one per file
 ```
 
 There is no index file. The frontmatter in each `log/` and `questions/` file is the
diff --git a/README.md b/README.md
index 8346d64..950fa2f 100644
--- a/README.md
+++ b/README.md
@@ -43,11 +43,15 @@ wherefore is an open, plain-markdown record of the reasoning behind your technic
 decisions. No cloud, no database, no vector store, no lock-in. Because the data is
 just files in your repo, any tool or any person can read it.
 
-There are three ways to work with it:
+There are a few ways to work with it:
 
 - **A Claude Code plugin** (the richest experience): skills that capture, query,
   resolve, and supersede decisions, with Claude handling the tagging and bookkeeping
   so the log actually gets maintained.
+- **The `wherefore` CLI** ([`wherefore`](https://www.npmjs.com/package/wherefore) on
+  npm): `npx wherefore init` scaffolds the log and an `AGENTS.md`, and
+  `npx wherefore dashboard` launches the dashboard. It can also install the skills for
+  your agent (Claude Code, Codex, Cursor, Copilot, Gemini, Antigravity) as an opt-in.
 - **A static dashboard** ([`@dustinvk/wherefore-dashboard`](https://www.npmjs.com/package/@dustinvk/wherefore-dashboard)
   on npm): renders your `wherefore/` directory as a browsable site, deployable to
   Cloudflare Pages.
@@ -155,6 +159,32 @@ Or equivalently from the repo root:
 node packages/wherefore-dashboard/bin/wherefore-dashboard.js dev --src ./wherefore
 ```
 
+## Setting up a project
+
+`npx wherefore init` scaffolds everything a project needs: a `wherefore/` directory
+(`log/`, `questions/`, `plan/`, and a starter `topics.md`), an `AGENTS.md` so any
+coding agent can read and maintain the log, and a `CLAUDE.md` snippet that makes Claude
+offer to capture decisions. It also adds a `dist/` line to `.gitignore` and a `wherefore`
+devDependency.
+
+By default it installs no agent skills. To also install the SKILL.md skills for your
+agent(s), opt in (experimental):
+
+```bash
+# the shared .agents/skills path (Copilot, Cursor, Gemini, Antigravity)
+npx wherefore init --skills
+
+# specific agents: claude, codex, copilot, cursor, gemini, antigravity, all, auto
+npx wherefore init --skills --agent claude,codex
+
+# detect agents from the repo, or install into your user-level dirs
+npx wherefore init --skills --agent auto
+npx wherefore init --skills --agent claude --global
+```
+
+`AGENTS.md` is always written and is the cross-tool floor; installing skills is an opt-in
+enhancement on top of it.
+
 ## Setup tips
 
 First-time setup in a project (optional but recommended):
@@ -212,6 +242,7 @@ wherefore/
 │   └── workflows/
 │       └── validate-plugins.yml       # CI: validates manifests + plugin on every push
 ├── packages/
+│   ├── wherefore/                     # the `wherefore` CLI: init + dashboard launcher (published to npm)
 │   └── wherefore-dashboard/           # the static dashboard (published to npm)
 ├── plugins/
 │   └── wherefore/
diff --git a/packages/wherefore-dashboard/README.md b/packages/wherefore-dashboard/README.md
index 986a7e9..5d32659 100644
--- a/packages/wherefore-dashboard/README.md
+++ b/packages/wherefore-dashboard/README.md
@@ -13,6 +13,10 @@ Wherefore captures the reasoning behind your engineering decisions, what you cho
 [![npm](https://img.shields.io/npm/v/@dustinvk/wherefore-dashboard)](https://www.npmjs.com/package/@dustinvk/wherefore-dashboard)
 [![license](https://img.shields.io/npm/l/@dustinvk/wherefore-dashboard)](https://github.com/DustinVK/wherefore/blob/main/LICENSE)
 
+> This package only builds and serves the dashboard. To scaffold a `wherefore/` log or
+> install skills for your agent, use the `wherefore` CLI: `npx wherefore init`. You can
+> also launch this dashboard through it with `npx wherefore dashboard`.
+
 ## Quick start
 
 From any directory that contains a `wherefore/` folder, no install and no flags:
diff --git a/packages/wherefore-dashboard/bin/wherefore-dashboard.js b/packages/wherefore-dashboard/bin/wherefore-dashboard.js
index 234eb12..738f59c 100755
--- a/packages/wherefore-dashboard/bin/wherefore-dashboard.js
+++ b/packages/wherefore-dashboard/bin/wherefore-dashboard.js
@@ -27,13 +27,14 @@ const USAGE = `wherefore-dashboard -- build or preview a static dashboard from a
 Usage:
   wherefore-dashboard build [--src <path>] [--out <path>] [--title <string>]
   wherefore-dashboard dev   [--src <path>] [--title <string>]
-  wherefore-dashboard init
 
 Options:
   --src <path>     Path to the wherefore/ directory to render. Default: ./wherefore
   --out <path>     Output directory for the built site. Default: ./dist
   --title <string> Override the dashboard title.
-  -h, --help       Show this help.`;
+  -h, --help       Show this help.
+
+To scaffold a wherefore/ log or install skills, use the wherefore CLI: npx wherefore init.`;
 
 function checkSrc(src) {
   const logDir = resolve(src, 'log');
@@ -113,13 +114,11 @@ if (command === 'build') {
   });
 
 } else if (command === 'init') {
-  console.log('init: not yet implemented.');
-  console.log('Intended: scaffold package.json with @dustinvk/wherefore-dashboard as devDependency,');
-  console.log('a .gitignore entry for dist/, and an optional wherefore-dashboard.config.json.');
+  console.error('init moved to the wherefore CLI. Run: npx wherefore init');
   process.exit(1);
 
 } else {
   console.error(`Unknown command: ${command ?? '(none)'}`);
-  console.error('Usage: wherefore-dashboard <build|dev|init> [--src <path>] [--out <path>] [--title <string>]');
+  console.error('Usage: wherefore-dashboard <build|dev> [--src <path>] [--out <path>] [--title <string>]');
   process.exit(1);
 }
diff --git a/packages/wherefore/.gitignore b/packages/wherefore/.gitignore
new file mode 100644
index 0000000..f4b20db
--- /dev/null
+++ b/packages/wherefore/.gitignore
@@ -0,0 +1,3 @@
+node_modules/
+skills/
+templates/
diff --git a/packages/wherefore/MANUAL_TESTING.md b/packages/wherefore/MANUAL_TESTING.md
new file mode 100644
index 0000000..07c8134
--- /dev/null
+++ b/packages/wherefore/MANUAL_TESTING.md
@@ -0,0 +1,113 @@
+# Manual testing plan: `wherefore` CLI
+
+`npm test` in this package already covers the mechanics: default-off skills, the
+per-agent / `all` / `auto` / unknown / global / force paths, the dashboard launcher
+(arg forwarding + exit code), and the CLAUDE.md / .gitignore / package.json regressions.
+
+This document covers what those tests cannot: running the packaged artifact the way a
+user would, and confirming that a real agent actually discovers the installed skills.
+Work through it before publishing.
+
+## Prerequisites
+
+- Node >= 18.
+- Pick how you'll run the CLI:
+  - **Packaged (preferred, closest to real usage).** From this directory, `npm pack`.
+    Its `prepack` script generates `skills/` and `templates/`, so the tarball is complete.
+    Then `npm i -g ./wherefore-0.1.0.tgz` and invoke `wherefore ...`. Uninstall with
+    `npm rm -g wherefore` when done.
+  - **Direct (fastest for iterating).** Run `node bin/prepare-package.js` once so
+    `skills/`/`templates/` exist, then `node bin/wherefore.js ...`. Skipping the prepare
+    step makes skill/AGENTS.md/CLAUDE.md steps fail.
+- Run every case in a throwaway project directory (`mkdir $(mktemp -d)` with a
+  `package.json` inside). For `--global`, set `HOME=$(mktemp -d)` on the command so you
+  never write to your real `~/.claude`, `~/.codex`, or `~/.agents`.
+
+Below, `wherefore` means whichever invocation you chose.
+
+## A. Help and dispatch
+
+| Command | Expected |
+| --- | --- |
+| `wherefore` / `wherefore --help` | Prints usage, exit 0 |
+| `wherefore bogus` | `Unknown command: bogus`, exit 1 |
+
+## B. Default init installs no skills
+
+In an empty dir containing a minimal `package.json`, run `wherefore init`. Expect exit 0
+and the console line `Skipping agent skill install (experimental; ...)`. Verify:
+
+- `wherefore/` has `log/`, `questions/`, `plan/`, and `topics.md`.
+- `AGENTS.md` exists (the always-on cross-tool floor).
+- `CLAUDE.md` contains `## Wherefore` and does **not** contain `paste from here` or
+  `Paste the block below`.
+- `package.json` gained a `wherefore` devDependency.
+- `.gitignore` contains a bare `dist/` line.
+- **No** `.agents/skills`, `.claude/skills`, or `.codex/skills` directories exist.
+
+## C. Idempotency
+
+Run `wherefore init` a second time in the same dir. Expect exit 0, "already exists"
+messages for topics/AGENTS/CLAUDE, and that `CLAUDE.md` still has exactly one `## Wherefore`
+block (no duplicate append). Confirm `package.json` was not rewritten (dependency not added
+twice, formatting unchanged).
+
+## D. Opt-in skill install
+
+Each in a fresh dir:
+
+| Command | Expected |
+| --- | --- |
+| `wherefore init --skills` | `.agents/skills/{capture,ask,resolve,supersede}/SKILL.md`; no `.claude`/`.codex` |
+| `wherefore init --skills --agent claude,codex` | `.claude/skills` and `.codex/skills` written; `.agents/skills` absent |
+| `wherefore init --skills --agent all` | all three roots written |
+| `mkdir .codex && wherefore init --skills --agent auto` | only `.codex/skills` written; `.cursor/skills` absent |
+| `wherefore init --skills --agent bogus` | exit 1, error lists valid agent names |
+| re-run `--agent claude` then again with `--force` | first re-run skips existing skill; `--force` overwrites it |
+| `HOME=$(mktemp -d) wherefore init --global --agent claude` | skill lands under that temp `HOME`'s `.claude/skills`, not the project |
+
+## E. Robustness
+
+- Put invalid JSON in `package.json`, then `wherefore init`. Expect a `Warning: Could not
+  update package.json` line, the rest of the scaffold still created, and a non-zero exit
+  with `Initialization completed with errors`.
+- Confirm a genuinely healthy run exits 0 (already covered in B, note it here for contrast).
+
+## F. Dashboard launcher
+
+- Override path: `WHEREFORE_DASHBOARD_BIN=/path/to/stub.js wherefore dashboard build --src x`
+  forwards `build --src x` to the stub and returns the stub's exit code. (This is what the
+  automated test does; rerun it manually if you touched the launcher.)
+- Real path: in a dir containing a `wherefore/`, run `wherefore dashboard dev`. It should
+  `npx @dustinvk/wherefore-dashboard dev` on demand (first run downloads it), serve the
+  dashboard, and stop cleanly on Ctrl-C. Try `wherefore dashboard --help` and confirm the
+  dashboard's own help appears (the launcher forwards `--help` rather than showing the CLI's).
+
+## G. Real cross-agent verification (the point of this doc)
+
+For each agent you actually have installed, install its skills and confirm the agent
+discovers them. This is the part unit tests can't reach.
+
+- **Claude Code:** `wherefore init --skills --agent claude`, then in Claude Code confirm the
+  four skills are discovered from `.claude/skills/`. Known limitation to eyeball: their
+  descriptions advertise `/wherefore:*` triggers, which only resolve for the marketplace
+  plugin, not for filesystem-installed skills.
+- **Codex CLI:** `--agent codex`, then run `codex` in that repo and confirm the skills load
+  from `.codex/skills/`. Separately confirm Codex reads the `AGENTS.md` floor with no skills
+  installed at all.
+- **Copilot / Cursor / Gemini / Antigravity:** `--agent <that agent>` (all write
+  `.agents/skills/`), open the tool, and confirm it discovers the skills there. For Cursor
+  and Codex, also confirm plain `AGENTS.md` (default init, no skills) is picked up.
+- Note any agent whose skill directory has moved since this was written; the paths in
+  `bin/wherefore.js` (`AGENT_DIRS`) may need updating.
+
+## H. Full end-to-end dry run
+
+In a throwaway project: `wherefore init`, capture a decision through whichever agent you
+set up (or hand-write a `wherefore/log/*.md`), then `wherefore dashboard build` and open the
+generated `dist/` to confirm the entry and any questions render.
+
+## Cleanup
+
+Remove the throwaway directories and temp `HOME`s. If you installed the tarball,
+`npm rm -g wherefore` and delete the `.tgz`.
diff --git a/packages/wherefore/bin/prepare-package.js b/packages/wherefore/bin/prepare-package.js
new file mode 100644
index 0000000..67c5ff7
--- /dev/null
+++ b/packages/wherefore/bin/prepare-package.js
@@ -0,0 +1,83 @@
+import { cp, rm, mkdir, stat, readdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PKG_ROOT = resolve(__dirname, '..');
+const REPO_ROOT = resolve(PKG_ROOT, '..', '..');
+
+const SKILLS_SRC = resolve(REPO_ROOT, 'plugins', 'wherefore', 'skills');
+const SNIPPET_SRC = resolve(REPO_ROOT, 'plugins', 'wherefore', 'CLAUDE.snippet.md');
+const AGENTS_SRC = resolve(REPO_ROOT, 'AGENTS.md');
+const SOURCES = [SKILLS_SRC, SNIPPET_SRC, AGENTS_SRC];
+
+const destSkills = resolve(PKG_ROOT, 'skills');
+const destTemplates = resolve(PKG_ROOT, 'templates');
+
+// Newest mtime anywhere under a file or directory tree.
+async function newestMtime(path) {
+  const info = await stat(path);
+  let newest = info.mtimeMs;
+  if (info.isDirectory()) {
+    for (const entry of await readdir(path, { withFileTypes: true })) {
+      const m = await newestMtime(resolve(path, entry.name));
+      if (m > newest) newest = m;
+    }
+  }
+  return newest;
+}
+
+async function main() {
+  const sourcesExist = SOURCES.every((p) => existsSync(p));
+  const assetsPresent = existsSync(destSkills) && existsSync(destTemplates);
+
+  // Outside the monorepo (e.g. an installed package), the sources are gone but the
+  // assets were already shipped in the tarball, so there is nothing to regenerate.
+  if (!sourcesExist) {
+    if (assetsPresent) {
+      console.log('Package assets already present; skipping generation.');
+      return;
+    }
+    console.warn('Package assets missing and source files unavailable; cannot generate skills/templates.');
+    return;
+  }
+
+  // Skip the rm+recopy when the generated assets are already newer than every
+  // source, so dev/build/test do not rebuild the whole tree on every run. Any
+  // error here (missing/racey files) falls through to a full, correct rebuild.
+  if (assetsPresent) {
+    try {
+      const srcNewest = Math.max(...(await Promise.all(SOURCES.map(newestMtime))));
+      const destNewest = Math.max(await newestMtime(destSkills), await newestMtime(destTemplates));
+      if (destNewest >= srcNewest) {
+        console.log('Package assets up to date; skipping regeneration.');
+        return;
+      }
+    } catch {
+      // fall through and rebuild
+    }
+  }
+
+  console.log('Preparing package assets (copying skills and templates)...');
+
+  // Clean old files
+  await rm(destSkills, { recursive: true, force: true });
+  await rm(destTemplates, { recursive: true, force: true });
+
+  // Create directories
+  await mkdir(destSkills, { recursive: true });
+  await mkdir(destTemplates, { recursive: true });
+
+  // Copy files
+  await cp(SKILLS_SRC, destSkills, { recursive: true });
+  await cp(SNIPPET_SRC, resolve(destTemplates, 'CLAUDE.snippet.md'));
+  await cp(AGENTS_SRC, resolve(destTemplates, 'AGENTS.md'));
+
+  console.log('Package assets prepared successfully.');
+}
+
+main().catch(err => {
+  console.error('Failed to prepare package assets:', err);
+  process.exit(1);
+});
diff --git a/packages/wherefore/bin/wherefore.js b/packages/wherefore/bin/wherefore.js
new file mode 100644
index 0000000..5145dc5
--- /dev/null
+++ b/packages/wherefore/bin/wherefore.js
@@ -0,0 +1,311 @@
+#!/usr/bin/env node
+import { cp, rm, readFile, writeFile, mkdir, rename } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { spawn } from 'node:child_process';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { homedir } from 'node:os';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PACKAGE_ROOT = resolve(__dirname, '..');
+
+// The dashboard lives in its own (astro-heavy) package; `wherefore` stays lean and
+// launches it on demand. WHEREFORE_DASHBOARD_BIN overrides the target for local dev/tests.
+const DASHBOARD_PKG = '@dustinvk/wherefore-dashboard';
+
+const USAGE = `wherefore -- capture and browse a repo-committed decision log
+
+Usage:
+  wherefore init      [--skills] [--agent <list>] [--global] [--force]
+  wherefore dashboard [...args]      launch the dashboard (forwards to ${DASHBOARD_PKG})
+
+Options:
+  --skills          (experimental) also install the wherefore skills for your agent(s).
+  --agent <list>    (experimental) comma-separated agents to install skills for:
+                    claude, codex, copilot, cursor, gemini, antigravity, all, auto.
+                    Default (with --skills, no --agent): the shared .agents/skills/ path.
+  --global          install skills into your user-level dirs instead of the project.
+  --force, -f       overwrite existing skills and configuration files.
+  -h, --help        show this help.
+
+init scaffolds a wherefore/ log, writes an AGENTS.md so any agent can read it, and
+(opt-in) installs SKILL.md skills for the agents you name.`;
+
+// Map an --agent name to the skills dir it auto-discovers (project-relative).
+// copilot/cursor/gemini/antigravity all read the shared .agents/skills path.
+const AGENT_DIRS = {
+  claude: '.claude/skills',
+  codex: '.codex/skills',
+  copilot: '.agents/skills',
+  cursor: '.agents/skills',
+  gemini: '.agents/skills',
+  antigravity: '.agents/skills',
+};
+
+// Best-effort markers used by --agent auto.
+const AUTO_MARKERS = [
+  { marker: '.claude', agent: 'claude' },
+  { marker: 'CLAUDE.md', agent: 'claude' },
+  { marker: '.codex', agent: 'codex' },
+  { marker: '.cursor', agent: 'cursor' },
+  { marker: '.gemini', agent: 'gemini' },
+  { marker: 'GEMINI.md', agent: 'gemini' },
+  { marker: '.github/copilot-instructions.md', agent: 'copilot' },
+  { marker: '.agents', agent: 'copilot' },
+];
+
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const command = args[0];
+  const flags = {};
+  for (let i = 1; i < args.length; i++) {
+    if (args[i] && args[i].startsWith('--') && args[i + 1] && !args[i + 1].startsWith('--')) {
+      flags[args[i].slice(2)] = args[i + 1];
+      i++;
+    }
+  }
+  return { command, flags };
+}
+
+// The CLAUDE.snippet.md template wraps the pasteable convention block in marker
+// comments and precedes it with human-facing paste instructions. Install only the
+// block between the markers so those instructions do not leak into CLAUDE.md.
+function extractSnippetBlock(content) {
+  const start = content.indexOf('paste from here');
+  const end = content.indexOf('to here', start + 1);
+  if (start === -1 || end === -1) return content.trim();
+  const afterStart = content.indexOf('-->', start);
+  const beforeEnd = content.lastIndexOf('<!--', end);
+  if (afterStart === -1 || beforeEnd === -1 || afterStart >= beforeEnd) return content.trim();
+  return content.slice(afterStart + 3, beforeEnd).trim();
+}
+
+// Resolve the requested agents to a deduped list of absolute skill dirs.
+function resolveSkillDirs({ agentArg, isGlobal, targetRoot }) {
+  let rel; // project-relative skill dirs
+  if (!agentArg) {
+    rel = ['.agents/skills']; // bare --skills -> the shared interop path
+  } else if (agentArg === 'all') {
+    rel = ['.claude/skills', '.codex/skills', '.agents/skills'];
+  } else if (agentArg === 'auto') {
+    const detected = new Set();
+    for (const { marker, agent } of AUTO_MARKERS) {
+      if (existsSync(resolve(targetRoot, marker))) detected.add(AGENT_DIRS[agent]);
+    }
+    if (detected.size === 0) return { dirs: [], error: 'no known agent markers found for --agent auto' };
+    rel = [...detected];
+  } else {
+    const names = agentArg.split(',').map((s) => s.trim()).filter(Boolean);
+    const unknown = names.filter((n) => !(n in AGENT_DIRS));
+    if (unknown.length) {
+      return {
+        dirs: [],
+        error: `unknown --agent value(s): ${unknown.join(', ')}. Valid: ${Object.keys(AGENT_DIRS).join(', ')}, all, auto`,
+      };
+    }
+    rel = [...new Set(names.map((n) => AGENT_DIRS[n]))];
+  }
+  const dirs = [...new Set(rel.map((r) => (isGlobal ? resolve(homedir(), r) : resolve(targetRoot, r))))];
+  return { dirs, error: null };
+}
+
+const { command, flags } = parseArgs(process.argv);
+const rawArgs = process.argv.slice(2);
+const wantsHelp = rawArgs.includes('--help') || rawArgs.includes('-h');
+
+// Global help, but let `dashboard --help` fall through to the dashboard itself.
+if (!command || command === 'help' || command === '--help' || command === '-h' || (wantsHelp && command !== 'dashboard')) {
+  console.log(USAGE);
+  process.exit(0);
+}
+
+if (command === 'dashboard') {
+  // Thin launcher: keep `wherefore` dependency-light and spawn the dashboard on demand.
+  const forwarded = rawArgs.slice(1);
+  const overrideBin = process.env.WHEREFORE_DASHBOARD_BIN;
+  const [cmd, baseArgs] = overrideBin
+    ? [process.execPath, [overrideBin]]
+    : ['npx', ['--yes', DASHBOARD_PKG]];
+  const child = spawn(cmd, [...baseArgs, ...forwarded], { stdio: 'inherit' });
+  child.on('error', (err) => {
+    console.error(`Failed to launch dashboard: ${err.message}`);
+    process.exit(1);
+  });
+  child.on('exit', (code) => process.exit(code ?? 0));
+
+} else if (command === 'init') {
+  const isGlobal = rawArgs.includes('--global');
+  const isForce = rawArgs.includes('--force') || rawArgs.includes('-f');
+  const targetRoot = process.cwd();
+  // Track whether any step actually errored (not just "already exists / skipped")
+  // so init can do as much setup as possible and still exit non-zero at the end.
+  let hadError = false;
+
+  // 1. Read this CLI's version to pin the consumer's devDependency.
+  let cliVersion = 'latest';
+  try {
+    const pkgJson = JSON.parse(await readFile(resolve(PACKAGE_ROOT, 'package.json'), 'utf8'));
+    cliVersion = `^${pkgJson.version}`;
+  } catch (_) {}
+
+  console.log('Initializing wherefore log structure...');
+
+  // 2. Create wherefore/ directories and seed topics.md if not exists
+  const whereforeDir = resolve(targetRoot, 'wherefore');
+  const logDir = resolve(whereforeDir, 'log');
+  const questionsDir = resolve(whereforeDir, 'questions');
+  const planDir = resolve(whereforeDir, 'plan');
+
+  await mkdir(logDir, { recursive: true });
+  await mkdir(questionsDir, { recursive: true });
+  await mkdir(planDir, { recursive: true });
+
+  const topicsPath = resolve(whereforeDir, 'topics.md');
+  if (!existsSync(topicsPath)) {
+    const seedTopicsPath = resolve(PACKAGE_ROOT, 'skills', 'capture', 'topics.seed.md');
+    try {
+      await cp(seedTopicsPath, topicsPath);
+      console.log('  Created wherefore/topics.md from seed template.');
+    } catch (err) {
+      console.warn(`  Warning: Could not seed topics.md: ${err.message}`);
+      hadError = true;
+    }
+  } else {
+    console.log('  wherefore/topics.md already exists, skipping seed.');
+  }
+
+  // 3. Scaffold package.json
+  const targetPkgJsonPath = resolve(targetRoot, 'package.json');
+  if (existsSync(targetPkgJsonPath)) {
+    try {
+      const pkgContent = await readFile(targetPkgJsonPath, 'utf8');
+      const pkg = JSON.parse(pkgContent);
+      if (!pkg.devDependencies) pkg.devDependencies = {};
+      if (!pkg.dependencies) pkg.dependencies = {};
+
+      const hasDep = pkg.devDependencies['wherefore'] || pkg.dependencies['wherefore'];
+      if (!hasDep) {
+        pkg.devDependencies['wherefore'] = cliVersion;
+        // Preserve the file's existing indentation and trailing newline so init
+        // adds one line rather than reformatting the whole file into a noisy diff.
+        const indentMatch = pkgContent.match(/\n([ \t]+)"/);
+        const indent = indentMatch ? indentMatch[1] : 2;
+        const trailingNewline = pkgContent.endsWith('\n') ? '\n' : '';
+        await writeFile(targetPkgJsonPath, JSON.stringify(pkg, null, indent) + trailingNewline, 'utf8');
+        console.log('  Added wherefore to devDependencies in package.json.');
+      } else {
+        console.log('  wherefore already in package.json.');
+      }
+    } catch (err) {
+      console.warn(`  Warning: Could not update package.json: ${err.message}`);
+      hadError = true;
+    }
+  }
+
+  // 4. Update .gitignore
+  const gitignorePath = resolve(targetRoot, '.gitignore');
+  let gitignoreContent = '';
+  if (existsSync(gitignorePath)) {
+    gitignoreContent = await readFile(gitignorePath, 'utf8');
+  }
+  const existingIgnores = new Set(gitignoreContent.split('\n').map((line) => line.trim()));
+  const linesToAppend = [];
+  // Match whole lines: a nested `frontend/dist/` must not mask a missing top-level
+  // `dist/` rule (the default dashboard build output the consumer produces).
+  if (!existingIgnores.has('dist/')) linesToAppend.push('dist/');
+
+  if (linesToAppend.length > 0) {
+    const divider = gitignoreContent.length === 0 || gitignoreContent.endsWith('\n') ? '' : '\n';
+    await writeFile(gitignorePath, gitignoreContent + divider + linesToAppend.join('\n') + '\n', 'utf8');
+    console.log('  Updated .gitignore to ignore dashboard build output.');
+  }
+
+  // 5. Install AGENTS.md (the always-on cross-tool floor)
+  const agentsPath = resolve(targetRoot, 'AGENTS.md');
+  const templateAgentsPath = resolve(PACKAGE_ROOT, 'templates', 'AGENTS.md');
+  const agentsExists = existsSync(agentsPath);
+  if (!agentsExists || isForce) {
+    try {
+      await cp(templateAgentsPath, agentsPath);
+      console.log(`  Created AGENTS.md in project root${isForce && agentsExists ? ' (overwritten)' : ''}.`);
+    } catch (err) {
+      console.warn(`  Warning: Could not create AGENTS.md: ${err.message}`);
+      hadError = true;
+    }
+  } else {
+    console.log('  AGENTS.md already exists, skipping. Pass --force to overwrite.');
+  }
+
+  // 6. Install CLAUDE.md setup snippet
+  const claudePath = resolve(targetRoot, 'CLAUDE.md');
+  const templateSnippetPath = resolve(PACKAGE_ROOT, 'templates', 'CLAUDE.snippet.md');
+  try {
+    const snippetContent = extractSnippetBlock(await readFile(templateSnippetPath, 'utf8'));
+    let existingClaude = '';
+    if (existsSync(claudePath)) {
+      existingClaude = await readFile(claudePath, 'utf8');
+    }
+
+    if (!existingClaude.includes('## Wherefore')) {
+      const divider = existingClaude.length === 0 || existingClaude.endsWith('\n') ? '' : '\n';
+      await writeFile(claudePath, existingClaude + divider + snippetContent + '\n', 'utf8');
+      console.log('  Appended wherefore snippet to CLAUDE.md.');
+    } else {
+      console.log('  CLAUDE.md already configured for wherefore plugin, skipping.');
+    }
+  } catch (err) {
+    console.warn(`  Warning: Could not configure CLAUDE.md: ${err.message}`);
+    hadError = true;
+  }
+
+  // 7. Install agent skills (experimental, opt-in)
+  const hasAgentArg = rawArgs.includes('--agent');
+  const wantsSkills = rawArgs.includes('--skills') || isGlobal || hasAgentArg;
+  if (wantsSkills) {
+    const { dirs, error } = resolveSkillDirs({ agentArg: flags.agent, isGlobal, targetRoot });
+    if (error) {
+      console.error(`  Error: ${error}`);
+      hadError = true;
+    } else {
+      for (const skillsDir of dirs) {
+        console.log(`Installing skills into ${skillsDir}...`);
+        try {
+          await mkdir(skillsDir, { recursive: true });
+          for (const skill of ['capture', 'ask', 'resolve', 'supersede']) {
+            const dest = resolve(skillsDir, skill);
+            const exists = existsSync(dest);
+            if (!exists || isForce) {
+              // Copy into a temp dir and swap in, so a failed copy never leaves the
+              // skill deleted with no replacement.
+              const tmpDest = `${dest}.tmp`;
+              await rm(tmpDest, { recursive: true, force: true });
+              await cp(resolve(PACKAGE_ROOT, 'skills', skill), tmpDest, { recursive: true });
+              if (exists) await rm(dest, { recursive: true, force: true });
+              await rename(tmpDest, dest);
+              console.log(`  Installed skill '${skill}'${isForce && exists ? ' (overwritten)' : ''}.`);
+            } else {
+              console.log(`  Skipped skill '${skill}' (already exists). Pass --force to overwrite.`);
+            }
+          }
+        } catch (err) {
+          console.error(`  Error installing skills into ${skillsDir}: ${err.message}`);
+          hadError = true;
+        }
+      }
+    }
+  } else {
+    console.log('Skipping agent skill install (experimental; pass --skills or --agent <name> to enable).');
+  }
+
+  if (hadError) {
+    console.error('\nInitialization completed with errors (see warnings above).');
+    process.exit(1);
+  }
+
+  console.log('\nInitialization complete! All set up.');
+
+} else {
+  console.error(`Unknown command: ${command ?? '(none)'}`);
+  console.error('Usage: wherefore <init|dashboard> [...]');
+  process.exit(1);
+}
diff --git a/packages/wherefore/package.json b/packages/wherefore/package.json
new file mode 100644
index 0000000..d8da06e
--- /dev/null
+++ b/packages/wherefore/package.json
@@ -0,0 +1,49 @@
+{
+  "name": "wherefore",
+  "version": "0.1.0",
+  "description": "Capture and browse a repo-committed decision log. Scaffolds wherefore/, writes AGENTS.md, and (opt-in) installs skills for your coding agent.",
+  "author": "Dustin VanKrimpen",
+  "license": "MIT",
+  "keywords": [
+    "wherefore",
+    "decision-log",
+    "adr",
+    "architecture",
+    "agents",
+    "skills",
+    "cli"
+  ],
+  "homepage": "https://github.com/DustinVK/wherefore#readme",
+  "bugs": {
+    "url": "https://github.com/DustinVK/wherefore/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DustinVK/wherefore.git",
+    "directory": "packages/wherefore"
+  },
+  "type": "module",
+  "engines": {
+    "node": ">=18"
+  },
+  "bin": {
+    "wherefore": "bin/wherefore.js"
+  },
+  "files": [
+    "bin",
+    "skills",
+    "templates"
+  ],
+  "scripts": {
+    "prepare-package": "node bin/prepare-package.js",
+    "test": "node bin/prepare-package.js && node --test tests/cli.test.js",
+    "prepack": "node bin/prepare-package.js",
+    "prepublishOnly": "node bin/prepare-package.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^26.0.1"
+  }
+}
diff --git a/packages/wherefore/tests/cli.test.js b/packages/wherefore/tests/cli.test.js
new file mode 100644
index 0000000..2d2aa04
--- /dev/null
+++ b/packages/wherefore/tests/cli.test.js
@@ -0,0 +1,196 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, rmSync, writeFileSync, readFileSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { tmpdir } from 'node:os';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const BIN = resolve(__dirname, '..', 'bin', 'wherefore.js');
+
+function spawn(args, opts = {}) {
+  return spawnSync(process.execPath, [BIN, ...args], {
+    encoding: 'utf-8',
+    timeout: opts.timeout ?? 10000,
+    cwd: opts.cwd,
+    env: { ...process.env, ...(opts.env ?? {}) },
+  });
+}
+
+function uniqueTemp(label) {
+  return resolve(tmpdir(), `wherefore-test-${label}-${Date.now()}`);
+}
+
+function withProject(label, fn) {
+  const cwd = uniqueTemp(label);
+  mkdirSync(cwd, { recursive: true });
+  writeFileSync(resolve(cwd, 'package.json'), JSON.stringify({ name: 'test-project', version: '1.0.0' }, null, 2), 'utf8');
+  try {
+    fn(cwd);
+  } finally {
+    rmSync(cwd, { recursive: true, force: true });
+  }
+}
+
+test('--help exits 0 and does not scaffold', () => {
+  const cwd = uniqueTemp('help');
+  mkdirSync(cwd, { recursive: true });
+  try {
+    const result = spawn(['--help'], { cwd });
+    assert.equal(result.status, 0);
+    assert.ok(!existsSync(resolve(cwd, 'wherefore')), 'help must not scaffold');
+  } finally {
+    rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
+test('default init scaffolds the log + AGENTS.md floor but installs NO skills', () => {
+  withProject('default', (cwd) => {
+    const result = spawn(['init'], { cwd });
+    assert.equal(result.status, 0);
+
+    assert.ok(existsSync(resolve(cwd, 'wherefore', 'log')), 'missing wherefore/log');
+    assert.ok(existsSync(resolve(cwd, 'wherefore', 'questions')), 'missing wherefore/questions');
+    assert.ok(existsSync(resolve(cwd, 'wherefore', 'plan')), 'missing wherefore/plan');
+    assert.ok(existsSync(resolve(cwd, 'wherefore', 'topics.md')), 'missing topics.md');
+    assert.ok(existsSync(resolve(cwd, 'AGENTS.md')), 'missing AGENTS.md');
+    assert.ok(existsSync(resolve(cwd, 'CLAUDE.md')), 'missing CLAUDE.md');
+
+    const pkg = JSON.parse(readFileSync(resolve(cwd, 'package.json'), 'utf8'));
+    assert.ok(pkg.devDependencies['wherefore'], 'missing wherefore devDependency');
+
+    // No skills by default.
+    assert.ok(!existsSync(resolve(cwd, '.agents', 'skills')), 'must not install .agents/skills by default');
+    assert.ok(!existsSync(resolve(cwd, '.claude', 'skills')), 'must not install .claude/skills by default');
+    assert.ok(!existsSync(resolve(cwd, '.codex', 'skills')), 'must not install .codex/skills by default');
+  });
+});
+
+test('init --skills installs into the shared .agents/skills path', () => {
+  withProject('skills', (cwd) => {
+    const result = spawn(['init', '--skills'], { cwd });
+    assert.equal(result.status, 0);
+    for (const skill of ['capture', 'ask', 'resolve', 'supersede']) {
+      assert.ok(
+        existsSync(resolve(cwd, '.agents', 'skills', skill, 'SKILL.md')),
+        `missing .agents/skills/${skill}/SKILL.md`
+      );
+    }
+    assert.ok(!existsSync(resolve(cwd, '.claude', 'skills')), 'should not touch .claude/skills');
+  });
+});
+
+test('init --skills --agent claude,codex writes only those targets', () => {
+  withProject('named', (cwd) => {
+    const result = spawn(['init', '--skills', '--agent', 'claude,codex'], { cwd });
+    assert.equal(result.status, 0);
+    assert.ok(existsSync(resolve(cwd, '.claude', 'skills', 'capture', 'SKILL.md')), 'missing claude skill');
+    assert.ok(existsSync(resolve(cwd, '.codex', 'skills', 'capture', 'SKILL.md')), 'missing codex skill');
+    assert.ok(!existsSync(resolve(cwd, '.agents', 'skills')), 'should not write .agents/skills for named agents');
+  });
+});
+
+test('init --skills --agent all writes all three roots', () => {
+  withProject('all', (cwd) => {
+    const result = spawn(['init', '--skills', '--agent', 'all'], { cwd });
+    assert.equal(result.status, 0);
+    assert.ok(existsSync(resolve(cwd, '.claude', 'skills', 'ask', 'SKILL.md')), 'missing claude');
+    assert.ok(existsSync(resolve(cwd, '.codex', 'skills', 'ask', 'SKILL.md')), 'missing codex');
+    assert.ok(existsSync(resolve(cwd, '.agents', 'skills', 'ask', 'SKILL.md')), 'missing agents');
+  });
+});
+
+test('init --skills --agent auto installs for detected markers only', () => {
+  withProject('auto', (cwd) => {
+    mkdirSync(resolve(cwd, '.codex'), { recursive: true });
+    const result = spawn(['init', '--skills', '--agent', 'auto'], { cwd });
+    assert.equal(result.status, 0);
+    assert.ok(existsSync(resolve(cwd, '.codex', 'skills', 'capture', 'SKILL.md')), 'auto should install codex');
+    assert.ok(!existsSync(resolve(cwd, '.cursor', 'skills')), 'auto should not install undetected cursor');
+  });
+});
+
+test('init --agent bogus exits non-zero', () => {
+  withProject('bogus', (cwd) => {
+    const result = spawn(['init', '--skills', '--agent', 'bogus'], { cwd });
+    assert.notEqual(result.status, 0);
+  });
+});
+
+test('init --agent claude skips existing skill, --force overwrites', () => {
+  withProject('force', (cwd) => {
+    mkdirSync(resolve(cwd, '.claude', 'skills', 'capture'), { recursive: true });
+    writeFileSync(resolve(cwd, '.claude', 'skills', 'capture', 'SKILL.md'), 'custom-capture', 'utf8');
+
+    const r1 = spawn(['init', '--skills', '--agent', 'claude'], { cwd });
+    assert.equal(r1.status, 0);
+    assert.equal(readFileSync(resolve(cwd, '.claude', 'skills', 'capture', 'SKILL.md'), 'utf8'), 'custom-capture');
+
+    const r2 = spawn(['init', '--skills', '--agent', 'claude', '--force'], { cwd });
+    assert.equal(r2.status, 0);
+    assert.notEqual(readFileSync(resolve(cwd, '.claude', 'skills', 'capture', 'SKILL.md'), 'utf8'), 'custom-capture');
+  });
+});
+
+test('init --global --agent claude installs into ~/.claude/skills (temp HOME)', () => {
+  const home = uniqueTemp('home');
+  mkdirSync(home, { recursive: true });
+  withProject('global', (cwd) => {
+    const result = spawn(['init', '--global', '--agent', 'claude'], { cwd, env: { HOME: home } });
+    assert.equal(result.status, 0);
+    assert.ok(existsSync(resolve(home, '.claude', 'skills', 'capture', 'SKILL.md')), 'missing global claude skill');
+  });
+  rmSync(home, { recursive: true, force: true });
+});
+
+test('CLAUDE.md gets only the marked block, not the paste instructions', () => {
+  withProject('claude-md', (cwd) => {
+    const result = spawn(['init'], { cwd });
+    assert.equal(result.status, 0);
+    const claude = readFileSync(resolve(cwd, 'CLAUDE.md'), 'utf8');
+    assert.ok(claude.includes('## Wherefore'), 'missing snippet');
+    assert.ok(!claude.includes('paste from here'), 'leaked paste-marker comments');
+    assert.ok(!claude.includes('Paste the block below'), 'leaked paste instructions');
+  });
+});
+
+test('init adds a top-level dist/ rule even when a nested dist/ is already ignored', () => {
+  withProject('gitignore', (cwd) => {
+    writeFileSync(resolve(cwd, '.gitignore'), 'node_modules/\nfrontend/dist/\n', 'utf8');
+    const result = spawn(['init'], { cwd });
+    assert.equal(result.status, 0);
+    const lines = readFileSync(resolve(cwd, '.gitignore'), 'utf8').split('\n').map((l) => l.trim());
+    assert.ok(lines.includes('dist/'), 'should add a bare dist/ rule');
+  });
+});
+
+test('init preserves existing package.json indentation and trailing newline', () => {
+  const cwd = uniqueTemp('pkgfmt');
+  mkdirSync(cwd, { recursive: true });
+  writeFileSync(resolve(cwd, 'package.json'), JSON.stringify({ name: 'p', version: '1.0.0' }, null, 4) + '\n', 'utf8');
+  try {
+    const result = spawn(['init'], { cwd });
+    assert.equal(result.status, 0);
+    const updated = readFileSync(resolve(cwd, 'package.json'), 'utf8');
+    assert.ok(updated.includes('\n    "'), 'should keep 4-space indentation');
+    assert.ok(updated.endsWith('\n'), 'should keep trailing newline');
+  } finally {
+    rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
+test('dashboard subcommand forwards args to the launcher and propagates exit code', () => {
+  const cwd = uniqueTemp('dash');
+  mkdirSync(cwd, { recursive: true });
+  // Stub stands in for the dashboard bin: echoes its args, exits with a fixed code.
+  const stub = resolve(cwd, 'stub.js');
+  writeFileSync(stub, 'console.log(process.argv.slice(2).join(" ")); process.exit(7);', 'utf8');
+  try {
+    const result = spawn(['dashboard', 'build', '--src', 'x'], { cwd, env: { WHEREFORE_DASHBOARD_BIN: stub } });
+    assert.equal(result.status, 7, 'should propagate the child exit code');
+    assert.ok(result.stdout.includes('build --src x'), 'should forward args to the dashboard');
+  } finally {
+    rmSync(cwd, { recursive: true, force: true });
+  }
+});
diff --git a/wherefore/log/2026-07-03-plan-directory.md b/wherefore/log/2026-07-03-plan-directory.md
new file mode 100644
index 0000000..6aae826
--- /dev/null
+++ b/wherefore/log/2026-07-03-plan-directory.md
@@ -0,0 +1,40 @@
+---
+date: 2026-07-03
+title: "Keep wherefore/plan/ for forward-looking plans"
+areas: [plugin, repo-structure]
+topics: [data-model, docs]
+stories: []
+status: active
+supersedes:
+superseded_by:
+superseded_date:
+---
+
+## Summary
+init scaffolds a `wherefore/plan/` directory that nothing referenced: not AGENTS.md's
+documented layout, not the dashboard, which renders only log/ and questions/. We kept it
+and documented it as the home for forward-looking plans, the counterpart to log/ for past
+decisions.
+
+## Decisions / outcomes
+- Keep `wherefore/plan/`. init continues to scaffold it in every project.
+- Document it in AGENTS.md as "forward-looking plans and roadmaps, one per file."
+- Scope it to plans not yet decided, distinct from log/ (decisions already made).
+
+## Why
+The directory was orphaned: created by init but missing from AGENTS.md's layout and
+unrendered by the dashboard, so it read as an accident. Removing it was the clean default,
+but it maps to a real gap. The log records decisions already made, and there was no home
+for plans still forming. Keeping and documenting it reserves that space now instead of
+reintroducing it later. Rendering plan/ in the dashboard is deferred until the format is
+actually used.
+
+## Alternatives considered
+- Remove plan/ from init and its test. Rejected: it fills a real gap and would likely be
+  re-added.
+- Keep it undocumented. Rejected: an empty, unexplained directory reads as a mistake and
+  invites deletion.
+
+## Open questions / follow-ups
+- None. Rendering plan/ in the dashboard is out of scope until entries exist.
+- See also: 2026-07-03-wherefore-cli-and-multi-agent-skills.
diff --git a/wherefore/log/2026-07-03-wherefore-cli-and-multi-agent-skills.md b/wherefore/log/2026-07-03-wherefore-cli-and-multi-agent-skills.md
new file mode 100644
index 0000000..03375ae
--- /dev/null
+++ b/wherefore/log/2026-07-03-wherefore-cli-and-multi-agent-skills.md
@@ -0,0 +1,58 @@
+---
+date: 2026-07-03
+title: "Lean wherefore CLI with opt-in agent skills"
+areas: [repo-structure, dashboard]
+topics: [distribution, cross-tool, publishing, naming]
+stories: []
+status: active
+supersedes:
+superseded_by:
+superseded_date:
+---
+
+## Summary
+The init capability first landed inside the astro-based `@dustinvk/wherefore-dashboard`
+package and installed skills into Antigravity by default. We split it into a new
+dependency-light npm package named `wherefore` (`npx wherefore init`), made skill
+install opt-in and multi-agent, and kept AGENTS.md as the always-on cross-tool floor.
+Skills remain experimental pending Q-008.
+
+## Decisions / outcomes
+- Publish the CLI as the unscoped `wherefore` package: `npx wherefore init` scaffolds
+  the log, and `npx wherefore dashboard` is a thin launcher that spawns
+  `@dustinvk/wherefore-dashboard` on demand (overridable via `WHEREFORE_DASHBOARD_BIN`).
+- Keep `wherefore` free of heavy dependencies (no astro) so init does not pull the
+  dashboard build stack just to scaffold text files.
+- Skills are opt-in via `--skills` / `--agent` / `--global`, never installed by default.
+  AGENTS.md is written on every init as the universal floor.
+- `--agent` accepts claude, codex, copilot, cursor, gemini, antigravity, plus `all` and
+  `auto`. copilot/cursor/gemini/antigravity share the `.agents/skills` path; claude uses
+  `.claude/skills`; codex uses `.codex/skills`. `--global` maps to the matching `~/` dirs.
+- Replaced the stale `~/.gemini/antigravity-cli/skills` global path with `~/.agents/skills`
+  and its per-agent siblings.
+
+## Why
+SKILL.md skills became a cross-tool standard across late 2025 and early 2026 (Claude Code,
+Codex, Cursor, Copilot, Gemini, and Antigravity all auto-discover skill dirs), so per-agent
+install is now feasible and worth exposing. Shipping init inside a package named "dashboard"
+was undiscoverable and dragged astro into a text-scaffolding command; naming it `wherefore`
+fixes discoverability and a lean package keeps `npx wherefore init` fast. Making skills
+opt-in preserves the earlier decision (see 2026-06-25-agents-md-cross-tool) that AGENTS.md is
+the plain-files floor: skills are an enhancement layered on top, not a replacement, so no
+strategy was silently reversed.
+
+## Alternatives considered
+- Rename the dashboard package to `wherefore`: simplest, but `npx wherefore init` would
+  download astro/esbuild/sharp just to scaffold files.
+- Install skills by default (as first built): rejected because it imposes an unresolved
+  cross-tool bet on every user and contradicts the AGENTS.md-floor decision.
+- Auto-detect agents only, no explicit flag: rejected as too magical for a non-interactive
+  CLI. `auto` is offered, but explicit `--agent` is the primary path.
+
+## Open questions / follow-ups
+- Q-008: whether to keep shipping per-agent skills at all, or rely solely on the AGENTS.md
+  floor for cross-tool.
+- Skill-adaptation gaps deferred until Q-008 resolves toward commit: descriptions advertise
+  `/wherefore:*` (only meaningful for the Claude Code plugin); capture writes a "Claude Code
+  skill" attribution into consumer repos; topics.seed.md rides into capture's installed skill
+  dir; no Antigravity-specific global path; skills have no version independent of `wherefore`.
diff --git a/wherefore/questions/Q-008.md b/wherefore/questions/Q-008.md
new file mode 100644
index 0000000..499def1
--- /dev/null
+++ b/wherefore/questions/Q-008.md
@@ -0,0 +1,10 @@
+---
+id: Q-008
+question: "Should wherefore ship opt-in per-agent SKILL.md skills, or rely solely on the AGENTS.md floor for cross-tool?"
+status: open
+areas: [repo-structure, plugin]
+asked_date: 2026-07-03
+asked_slug: 2026-07-03-wherefore-cli-and-multi-agent-skills
+resolution:
+resolution_slug:
+---