@skyf0xx/hedgehog 3.0.5 → 3.0.6

package/README.md

@@ -101,7 +101,7 @@ scoped file access and a verification command per layer.
 
 ## Install
 
-From an empty project folder, ask Claude to run:
+From an empty project folder, run:
 
 ``` bash
 # Full-stack app
@@ -114,7 +114,29 @@ npx @skyf0xx/hedgehog init --landing-page
 npx @skyf0xx/hedgehog init
 ```
 
-Then open Claude Code and describe what you want to build.
+Then open your coding agent and describe what you want to build.
+
+### Coding agents
+
+Hedgehog installs for **Claude Code** by default. Add a host flag to
+install for another one, or several at once:
+
+``` bash
+npx @skyf0xx/hedgehog init --cursor              # Cursor
+npx @skyf0xx/hedgehog init --gemini              # Gemini CLI
+npx @skyf0xx/hedgehog init --host=claude,cursor  # both
+npx @skyf0xx/hedgehog init --all-hosts           # every supported agent
+```
+
+Each one gets the discipline in its own native shape — agents and skills
+in the directory it reads, and the instructions file it loads at session
+start (`CLAUDE.md`, `HEDGEHOG.md`, or `GEMINI.md`).
+
+Every install also writes **`AGENTS.md`** at the repo root: an index of
+every agent and skill, when each applies, and the build loop. Coding
+agents that read `AGENTS.md` — Codex, Copilot CLI, OpenCode, and others —
+work from that index, following the same ordered steps and the same
+`hedgehog verify` gate.
 
 Plain `init` (no core flag) installs the agents, skills, and build graph
 that every core shares. Planning intake designs an opinionated build
@@ -128,9 +150,11 @@ To update:
 npx @skyf0xx/hedgehog update
 ```
 
-This refreshes `.claude/agents/` and `.claude/skills/` only. It never
-touches `CLAUDE.md`, the build graph, the core workspace, or
-`skills/BMAD`, since those carry project-specific or write-once content.
+This refreshes the installed agents and skills — for every coding agent
+the project was set up for — along with the `AGENTS.md` index derived
+from them. It never touches the instructions file, the build graph, the
+core workspace, or `skills/BMAD`, since those carry project-specific or
+write-once content.
 
 To see the build graph:
 
@@ -139,16 +163,7 @@ npx @skyf0xx/hedgehog graph
 ```
 
 Starts a small local server and opens a live, read-only diagram of every
-task and its dependencies — one node per task, coloured by lifecycle
-status, laid out top-to-bottom by dependency order. Click a task to see
-its objective, verify command, and commit message; click empty canvas to
-close it. The page polls for changes, so it keeps updating on its own as
-`hedgehog verify` moves tasks through their lifecycle — no re-running the
-command or reloading the page. Running `graph` again while a server is
-already up reuses it instead of starting a second one. Pass `--no-open`
-to start (or reuse) the server and print its URL instead of launching a
-browser. `hedgehog plan` opens the same live view automatically whenever
-it compiles new tasks.
+task, status and its dependencies.
 
 ## Why Hedgehog
 

package/bin/cli.mjs

@@ -6,8 +6,10 @@
 //   npx @skyf0xx/hedgehog init                        install; planner picks the core at intake
 //   npx @skyf0xx/hedgehog init --ts-full-stack-app     scaffold the full-stack-app core now
 //   npx @skyf0xx/hedgehog init --landing-page          scaffold the landing-page core now
+//   npx @skyf0xx/hedgehog init --cursor                install for Cursor (default: Claude Code)
+//   npx @skyf0xx/hedgehog init --all-hosts             install for every supported coding agent
 //   npx @skyf0xx/hedgehog init --force                 overwrite files that already exist
-//   npx @skyf0xx/hedgehog update                       refresh .claude/agents + .claude/skills
+//   npx @skyf0xx/hedgehog update                       refresh the installed agents + skills
 //   npx @skyf0xx/hedgehog --help
 
 import { cp, mkdir, access, readdir, stat, rm, readFile, writeFile } from 'node:fs/promises';
@@ -25,6 +27,8 @@ import { verifyTask } from '../src/db/verify.mjs';
 import { graphStatus, formatStatus } from '../src/db/status.mjs';
 import { whyPath, formatWhy } from '../src/db/why.mjs';
 import { addFriction, listFriction } from '../src/db/friction.mjs';
+import { HOSTS, HOST_FLAGS, DEFAULT_HOST, availableHosts } from '../src/hosts/index.mjs';
+import { recordHosts, installedHosts } from '../src/hosts/installed.mjs';
 
 const AUTHORED_CORE_PATH = '.hedgehog/core.yaml';
 
@@ -84,26 +88,49 @@ async function availableCores() {
 // core `planner` picks — the first time either way. An explicit flag
 // (`--ts-full-stack-app`, `--landing-page`) is a confirmed choice, so it
 // scaffolds that workspace immediately, at install time.
-function plan(core) {
-  const base = [
-    { type: 'dir', from: 'src/agents', to: '.claude/agents' },
-    { type: 'dir', from: 'src/skills', to: '.claude/skills' },
-    // The vendored BMAD-METHOD planning shelf that hedgehog-planning-intake
-    // runs — referenced by repo-root-relative path (skills/BMAD/...), so it
-    // lands there rather than under .claude/.
-    { type: 'dir', from: 'skills/BMAD', to: 'skills/BMAD' },
-    // The vendored GSAP animation skill shelf that front-end-eng loads for
-    // motion work — same repo-root-relative referencing as skills/BMAD.
-    { type: 'dir', from: 'skills/GSAP', to: 'skills/GSAP' },
+// `hostOnly` plans just the parts that differ per host — used when a
+// second host is added to a project whose shared payload (the vendored
+// shelves, the core workspace) is already on disk.
+function plan(core, host = DEFAULT_HOST, { hostOnly = false } = {}) {
+  const h = HOSTS[host];
+  const perHost = [
+    { type: 'dir', from: 'src/agents', to: h.agentsDir, emit: h.emitAgent },
+    { type: 'dir', from: 'src/skills', to: h.skillsDir },
+    // Whatever else this host needs to find the payload — its own rules
+    // file, extension manifest, or routing doc. Empty for a host that
+    // auto-loads its bootstrap file and registers agents from disk.
+    ...(h.extraEntries ?? []),
   ];
 
+  // Host-independent: one copy per project however many hosts read it.
+  const shared = hostOnly
+    ? []
+    : [
+        // The vendored BMAD-METHOD planning shelf that
+        // hedgehog-planning-intake runs — referenced by repo-root-relative
+        // path (skills/BMAD/...), so it lands there rather than under a
+        // host's own directory.
+        { type: 'dir', from: 'skills/BMAD', to: 'skills/BMAD' },
+        // The vendored GSAP animation skill shelf that front-end-eng loads
+        // for motion work — same repo-root-relative referencing.
+        { type: 'dir', from: 'skills/GSAP', to: 'skills/GSAP' },
+      ];
+
+  const base = [...perHost, ...shared];
+
   if (core === null) {
     return [
       ...base,
       // The shell with its {{CORE_SECTION}} placeholder left unfilled —
       // whichever bootstrap-core skill runs first fills it in for the
-      // core planner actually picked.
-      { type: 'file', from: 'src/templates/CLAUDE.md', to: 'CLAUDE.md' },
+      // core planner actually picked. {{HOST_DISPATCH}} is filled now:
+      // which host this is doesn't depend on the core.
+      {
+        type: 'merge',
+        shell: 'src/templates/CLAUDE.md',
+        dispatch: `src/hosts/${host}/DISPATCH.md`,
+        to: h.bootstrapFile,
+      },
     ];
   }
 
@@ -113,30 +140,37 @@ function plan(core) {
       type: 'merge',
       shell: 'src/templates/CLAUDE.md',
       include: `src/templates/CLAUDE.core.${core}.md`,
-      to: 'CLAUDE.md',
+      dispatch: `src/hosts/${host}/DISPATCH.md`,
+      to: h.bootstrapFile,
     },
     // The pre-built, pre-verified workspace for the chosen core —
     // everything a fresh project of that shape needs at repo root
     // (lands the root package.json too, so there's no separate
     // placeholder for it). The relevant bootstrap-core skill verifies
     // this on first run rather than generating it live.
-    { type: 'dir', from: `src/golden-cores/${core}`, to: '.' },
+    ...(hostOnly ? [] : [{ type: 'dir', from: `src/golden-cores/${core}`, to: '.' }]),
   ];
 }
 
 // The subset of plan() that's the discipline's payload rather than
 // project-specific or write-once content: `update` re-copies exactly
-// this, always overwriting, since a consuming project's own
-// .claude/agents and .claude/skills are supposed to match upstream
-// verbatim. CLAUDE.md carries project-filled content, the build graph
-// and core workspace are verified once by their own init/bootstrap-core
-// steps, and skills/BMAD and skills/GSAP are re-vendored only
-// deliberately (a manual re-vendor, per each shelf's ATTRIBUTION.md) —
-// none of those belong in an update.
-const UPDATE_PLAN = [
-  { type: 'dir', from: 'src/agents', to: '.claude/agents' },
-  { type: 'dir', from: 'src/skills', to: '.claude/skills' },
-];
+// this, always overwriting, since a consuming project's installed agents
+// and skills are supposed to match upstream verbatim. The bootstrap file
+// carries project-filled content, the build graph and core workspace are
+// verified once by their own init/bootstrap-core steps, and skills/BMAD
+// and skills/GSAP are re-vendored only deliberately (a manual re-vendor,
+// per each shelf's ATTRIBUTION.md) — none of those belong in an update.
+function updatePlan(host = DEFAULT_HOST) {
+  const h = HOSTS[host];
+  return [
+    { type: 'dir', from: 'src/agents', to: h.agentsDir, emit: h.emitAgent },
+    { type: 'dir', from: 'src/skills', to: h.skillsDir },
+    // Derived from the agents and skills above — an agent added, renamed,
+    // or redescribed upstream has to be reflected in the index that
+    // points at it, so it is regenerated alongside them.
+    ...(h.extraEntries ?? []).filter((e) => e.type === 'generated'),
+  ];
+}
 
 const exists = (p) =>
   access(p, constants.F_OK).then(
@@ -150,9 +184,29 @@ const exists = (p) =>
 async function writePlannedFile(f) {
   await mkdir(dirname(f.dest), { recursive: true });
   if (f.merge) {
-    const shell = await readFile(join(PKG_ROOT, f.merge.shell), 'utf8');
-    const section = await readFile(join(PKG_ROOT, f.merge.include), 'utf8');
-    await writeFile(f.dest, shell.replaceAll('{{CORE_SECTION}}', section.trimEnd()));
+    let out = await readFile(join(PKG_ROOT, f.merge.shell), 'utf8');
+    // A deferred install has no core yet, so {{CORE_SECTION}} stays put
+    // for whichever bootstrap-core skill runs first to fill in. The host
+    // is always known at install time, so {{HOST_DISPATCH}} never is.
+    if (f.merge.include) {
+      const section = await readFile(join(PKG_ROOT, f.merge.include), 'utf8');
+      out = out.replaceAll('{{CORE_SECTION}}', section.trimEnd());
+    }
+    const dispatch = await readFile(join(PKG_ROOT, f.merge.dispatch), 'utf8');
+    await writeFile(f.dest, out.replaceAll('{{HOST_DISPATCH}}', dispatch.trimEnd()));
+    return;
+  }
+  // Rendered from the payload rather than copied from it — the routing
+  // doc's tables are built from the agents' and skills' own frontmatter.
+  if (f.generate) {
+    await writeFile(f.dest, await f.generate({ pkgRoot: PKG_ROOT, projectRoot: DEST_ROOT }));
+    return;
+  }
+  // A host whose format differs from the canonical one rewrites the file
+  // on the way in. Hosts that read the canonical format have no emitter,
+  // so their payload is copied verbatim.
+  if (f.emit) {
+    await writeFile(f.dest, f.emit(await readFile(f.src, 'utf8'), { src: f.src }));
     return;
   }
   await cp(f.src, f.dest);
@@ -163,9 +217,12 @@ async function plannedFiles(entry) {
   if (entry.type === 'merge') {
     return [{ dest: join(DEST_ROOT, entry.to), merge: entry }];
   }
+  if (entry.type === 'generated') {
+    return [{ dest: join(DEST_ROOT, entry.to), generate: entry.generate }];
+  }
   const src = join(PKG_ROOT, entry.from);
   if (entry.type === 'file') {
-    return [{ src, dest: join(DEST_ROOT, entry.to) }];
+    return [{ src, dest: join(DEST_ROOT, entry.to), emit: entry.emit }];
   }
   const out = [];
   async function walk(rel) {
@@ -175,7 +232,7 @@ async function plannedFiles(entry) {
       for (const name of await readdir(abs)) await walk(join(rel, name));
     } else {
       const renamed = DOTFILE_RENAMES[rel] ?? rel;
-      out.push({ src: abs, dest: join(DEST_ROOT, entry.to, renamed) });
+      out.push({ src: abs, dest: join(DEST_ROOT, entry.to, renamed), emit: entry.emit });
     }
   }
   await walk('.');
@@ -187,16 +244,20 @@ async function help() {
   console.log(`
 ${bold('Hedgehog installer')}
 
-Copies the Hedgehog agents and skills into ${bold('.claude/')}, drops the
-CLAUDE.md template and an empty build graph (${bold('.hedgehog/hedgehog.db')})
-into the repo root, so the discipline is committed alongside your code.
+Copies the Hedgehog agents and skills into your coding agent's own
+directory, drops that agent's instructions file, an AGENTS.md index, and an
+empty build graph (${bold('.hedgehog/hedgehog.db')}) into the repo root, so
+the discipline is committed alongside your code.
 
 ${bold('Usage')}
   npx @skyf0xx/hedgehog init                      install; planner picks the core at intake
   npx @skyf0xx/hedgehog init --ts-full-stack-app  scaffold the full-stack-app core now
   npx @skyf0xx/hedgehog init --landing-page       scaffold the landing-page core now
+  npx @skyf0xx/hedgehog init --cursor             install for Cursor (default: Claude Code)
+  npx @skyf0xx/hedgehog init --host=claude,gemini install for several coding agents at once
+  npx @skyf0xx/hedgehog init --all-hosts          install for every supported coding agent
   npx @skyf0xx/hedgehog init --force              overwrite existing files
-  npx @skyf0xx/hedgehog update                    refresh .claude/agents + .claude/skills
+  npx @skyf0xx/hedgehog update                    refresh the installed agents + skills
   npx @skyf0xx/hedgehog db init                   create .hedgehog/hedgehog.db if absent
   npx @skyf0xx/hedgehog plan                      compile pending intents into tasks + dependencies,
                                                    then open the build graph if anything compiled
@@ -213,10 +274,11 @@ ${bold('Usage')}
   npx @skyf0xx/hedgehog --help
 
 Available cores: ${cores.join(', ')}
+Available hosts: ${availableHosts().join(', ')} (default: ${DEFAULT_HOST})
 
-After it runs, commit the payload, open Claude Code, and describe what
-you want to build — the planner agent runs planning intake, then hands
-off to bootstrap.
+After it runs, commit the payload, open your coding agent, and describe
+what you want to build — the planner agent runs planning intake, then
+hands off to bootstrap.
 
 Building something else (a CLI, library, browser extension, data
 pipeline, desktop app, etc.)? Run plain 'init' with no core flag rather
@@ -226,16 +288,17 @@ shares. The planner agent designs a core at planning intake
 (hedgehog-core-design) and bootstrap generates that workspace once it's
 confirmed. Describe the actual project and let Phase 0 route it.
 
-${bold('update')} re-copies only .claude/agents and .claude/skills from the
-installed Hedgehog version, so an already-bootstrapped project can pick up
-agent/skill changes from a newer release. It always overwrites those two
-directories and never touches CLAUDE.md, the build graph, the core
-workspace, or skills/BMAD and skills/GSAP — those are project-specific or
-updated deliberately, not by this command.
+${bold('update')} re-copies the agents and skills (and the AGENTS.md index
+derived from them) from the installed Hedgehog version, so an
+already-bootstrapped project can pick up changes from a newer release. It
+refreshes every host the project was installed for, always overwriting
+those directories. The instructions file, the build graph, the core
+workspace, and skills/BMAD and skills/GSAP stay as they are — those are
+project-specific or updated deliberately, not by this command.
 `);
 }
 
-async function init({ force, core, explicitCore }) {
+async function init({ force, core, explicitCore, host = DEFAULT_HOST, hostOnly = false }) {
   if (explicitCore) {
     const cores = await availableCores();
     if (!cores.includes(core)) {
@@ -251,13 +314,18 @@ async function init({ force, core, explicitCore }) {
   // before touching anything. A deferred install (no explicit core) plans
   // against `null` — the shared agents/skills/build-graph payload only.
   const groups = [];
-  for (const entry of plan(explicitCore ? core : null)) {
+  for (const entry of plan(explicitCore ? core : null, host, { hostOnly })) {
     const files = await plannedFiles(entry);
     groups.push({ entry, files });
   }
 
+  // A generated file is derived from the payload rather than authored in
+  // the project, so rewriting it loses nothing and never counts as a
+  // conflict — that's what lets a second host be added to a project the
+  // first one already set up.
   const conflicts = [];
-  for (const { files } of groups) {
+  for (const { entry, files } of groups) {
+    if (entry.type === 'generated') continue;
     for (const f of files) {
       if (await exists(f.dest)) conflicts.push(f.dest);
     }
@@ -275,6 +343,10 @@ async function init({ force, core, explicitCore }) {
     return;
   }
 
+  // Recorded before anything is written: the routing doc is generated
+  // from this list, so it has to already name the host being installed.
+  await recordHosts(DEST_ROOT, [host]);
+
   let written = 0;
   let overwritten = 0;
   for (const { files } of groups) {
@@ -301,10 +373,10 @@ async function init({ force, core, explicitCore }) {
   if (explicitCore) {
     console.log(`  1. ${bold('git add -A && git commit -m "chore: install Hedgehog"')}`);
     console.log(`  2. ${bold('pnpm install')}`);
-    console.log(`  3. Open Claude Code and describe what you want to build.`);
+    console.log(`  3. Open ${HOSTS[host].label} and describe what you want to build.`);
   } else {
     console.log(`  1. ${bold('git add -A && git commit -m "chore: install Hedgehog"')}`);
-    console.log(`  2. Open Claude Code and describe what you want to build.`);
+    console.log(`  2. Open ${HOSTS[host].label} and describe what you want to build.`);
   }
   console.log(
     dim(
@@ -333,36 +405,55 @@ async function init({ force, core, explicitCore }) {
   }
 }
 
-async function update() {
-  // Full replace, not a merge: clear each destination dir first so a
-  // rename or removal upstream (e.g. an agent renamed between releases)
-  // doesn't leave a stale file sitting alongside the new one.
-  for (const entry of UPDATE_PLAN) {
-    await rm(join(DEST_ROOT, entry.to), { recursive: true, force: true });
-  }
+async function update({ hosts }) {
+  const targets = hosts?.length ? hosts : await installedHosts(DEST_ROOT);
 
   let written = 0;
-  for (const entry of UPDATE_PLAN) {
-    const files = await plannedFiles(entry);
-    for (const f of files) {
-      await mkdir(dirname(f.dest), { recursive: true });
-      await cp(f.src, f.dest);
-      written++;
-      console.log(`  ${green('update')}  ${relative(DEST_ROOT, f.dest)}`);
+  for (const host of targets) {
+    const entries = updatePlan(host);
+
+    // Full replace, not a merge: clear each payload directory first so a
+    // rename or removal upstream (e.g. an agent renamed between releases)
+    // doesn't leave a stale file sitting alongside the new one. Generated
+    // files are single files rewritten in place, so they're left alone.
+    for (const entry of entries) {
+      if (entry.type === 'dir') {
+        await rm(join(DEST_ROOT, entry.to), { recursive: true, force: true });
+      }
+    }
+
+    for (const entry of entries) {
+      for (const f of await plannedFiles(entry)) {
+        await writePlannedFile(f);
+        written++;
+        console.log(`  ${green('update')}  ${relative(DEST_ROOT, f.dest)}`);
+      }
     }
   }
 
+  const label = targets.map((h) => HOSTS[h].label).join(', ');
   console.log(
-    `\n${green(bold('Hedgehog agents/skills updated.'))} ${dim(`${written} files written`)}\n`,
+    `\n${green(bold('Hedgehog agents/skills updated.'))} ${dim(
+      `${written} files written for ${label}`,
+    )}\n`,
   );
   console.log('Next steps:');
-  console.log(`  1. ${bold('git diff .claude/')} to review what changed`);
+  const reviewDirs = [
+    ...new Set(
+      targets.map((h) => {
+        const d = dirname(HOSTS[h].agentsDir);
+        return d === '.' ? HOSTS[h].agentsDir : `${d}/`;
+      }),
+    ),
+  ];
+  console.log(`  1. ${bold(`git diff ${reviewDirs.join(' ')}`)} to review what changed`);
   console.log(`  2. ${bold('git add -A && git commit -m "chore: update hedgehog"')}\n`);
+  const bootstraps = [...new Set(targets.map((h) => HOSTS[h].bootstrapFile))].join(', ');
   console.log(
     dim(
-      'CLAUDE.md, the build graph, the core workspace, and skills/BMAD\n' +
-        'and skills/GSAP are untouched — those carry project-specific or\n' +
-        'write-once content.',
+      `${bootstraps}, the build graph, the core workspace, and\n` +
+        'skills/BMAD and skills/GSAP are untouched — those carry\n' +
+        'project-specific or write-once content.',
     ),
   );
 }
@@ -912,13 +1003,46 @@ async function main() {
   }
   const core = coreFlag ? CORE_FLAGS[coreFlag] : DEFAULT_CORE;
 
+  // Which coding agent this repo is being set up for. `--host=<name>` and
+  // the per-host shorthand flags are equivalent; absent either, the
+  // default host applies.
+  const allHosts = args.includes('--all-hosts');
+  const hostFlags = args.filter((a) => a in HOST_FLAGS).map((a) => HOST_FLAGS[a]);
+  const hostEq = args
+    .filter((a) => a.startsWith('--host='))
+    .flatMap((a) => a.slice('--host='.length).split(','))
+    .map((h) => h.trim())
+    .filter(Boolean);
+  const named = [...new Set([...hostFlags, ...hostEq])];
+  const unknown = named.filter((h) => !(h in HOSTS));
+  if (unknown.length) {
+    console.error(
+      `${red('Unknown host:')} ${unknown.join(', ')}\n\n` +
+        `Available hosts: ${availableHosts().join(', ')}\n`,
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const hosts = allHosts ? availableHosts() : named;
+
   if (cmd === 'init') {
-    await init({ force, core, explicitCore: Boolean(coreFlag) });
+    // The shared payload — vendored shelves, core workspace — lands with
+    // the first host; the rest add only what differs per host.
+    const targets = hosts.length ? hosts : [DEFAULT_HOST];
+    for (const [i, host] of targets.entries()) {
+      await init({
+        force,
+        core,
+        explicitCore: Boolean(coreFlag),
+        host,
+        hostOnly: i > 0,
+      });
+    }
     return;
   }
 
   if (cmd === 'update') {
-    await update();
+    await update({ hosts });
     return;
   }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@skyf0xx/hedgehog",
-  "version": "3.0.5",
-  "description": "Install the Hedgehog build discipline (agents + skills) into a repo.",
+  "version": "3.0.6",
+  "description": "Install the Hedgehog build discipline (agents + skills) into a repo, for Claude Code, Cursor, or Gemini CLI.",
   "type": "module",
   "repository": {
     "type": "git",
@@ -20,6 +20,7 @@
     "bin",
     "src/agents",
     "src/db",
+    "src/hosts",
     "src/skills",
     "src/templates",
     "src/golden-cores",
@@ -32,6 +33,9 @@
   "keywords": [
     "claude",
     "claude-code",
+    "cursor",
+    "gemini-cli",
+    "agents-md",
     "agents",
     "skills",
     "scaffold",

package/src/db/graph.mjs

@@ -18,6 +18,16 @@ const ALL_DEPENDENCIES_SQL = `
   SELECT task_id, depends_on_task_id FROM dependencies;
 `;
 
+// One query for every task's requirement links, not one query per task —
+// this runs on every poll (see graph-server.mjs), so an N+1 here would
+// mean N+1 queries every 2 seconds rather than once.
+const ALL_TASK_REQUIREMENTS_SQL = `
+  SELECT tr.task_id, r.kind, r.statement
+  FROM task_requirements tr
+  JOIN requirements r ON r.id = tr.requirement_id
+  ORDER BY tr.task_id, r.id;
+`;
+
 function loadAllTasks(db) {
   return db.prepare(ALL_TASKS_SQL).all();
 }
@@ -26,13 +36,32 @@ function loadAllDependencies(db) {
   return db.prepare(ALL_DEPENDENCIES_SQL).all();
 }
 
+function loadAllTaskRequirements(db) {
+  return db.prepare(ALL_TASK_REQUIREMENTS_SQL).all();
+}
+
+// Groups the flat requirement rows by task_id, same rule/constraint/
+// acceptance mix hedgehog next's RELEVANT RULES section shows — a task
+// is bound by all three kinds equally, so the graph's detail panel
+// doesn't split them out either.
+function groupRequirementsByTask(rows) {
+  const byTask = new Map();
+  for (const row of rows) {
+    if (!byTask.has(row.task_id)) byTask.set(row.task_id, []);
+    byTask.get(row.task_id).push({ kind: row.kind, statement: row.statement });
+  }
+  return byTask;
+}
+
 // Shapes the full build graph into { nodes, edges } for the viewer.
 // Each node carries exactly the fields the viewer displays on click
-// (objective, verify_command, commit_message) plus the fields that drive
-// layout and status colour — nothing the viewer doesn't render.
+// (objective, verify_command, commit_message, requirements) plus the
+// fields that drive layout and status colour — nothing the viewer
+// doesn't render.
 export function buildGraph(db) {
   const tasks = loadAllTasks(db);
   const dependencies = loadAllDependencies(db);
+  const requirementsByTask = groupRequirementsByTask(loadAllTaskRequirements(db));
 
   const nodes = tasks.map((t) => ({
     id: t.id,
@@ -43,6 +72,7 @@ export function buildGraph(db) {
     verifyCommand: t.verify_command,
     commitMessage: t.commit_message,
     intentGoal: t.intent_goal,
+    requirements: requirementsByTask.get(t.id) ?? [],
   }));
 
   // Edge direction follows the dependency, not the SQL column order:

package/src/hosts/capabilities.mjs

@@ -0,0 +1,89 @@
+// Which tools each agent role needs, named as a host-neutral capability.
+//
+// Each host spells its tool grant in its own vocabulary, so the grant is
+// stated once here and mapped per host below. This file owns the
+// agent -> capability fact; `src/agents/*.md` carries the Claude Code
+// spelling of it in its `tools:` frontmatter, which Claude Code reads
+// directly.
+
+/** @typedef {'full'|'no-bash'|'readonly-bash'|'readonly'|'write-only'} Capability */
+
+/** @type {Record<string, Capability>} */
+export const AGENT_CAPABILITY = {
+  // Build and scaffold: read, write, and run commands.
+  'backend-eng': 'full',
+  bootstrap: 'full',
+  'front-end-eng': 'full',
+  'landing-builder': 'full',
+  'landing-copywriter': 'full',
+  'layer-eng': 'full',
+  planner: 'full',
+  tweaker: 'full',
+
+  // Author artifacts, but never run commands.
+  'landing-headline-writer': 'no-bash',
+  'landing-sequencer': 'no-bash',
+  'landing-strategist': 'no-bash',
+  'landing-systems': 'no-bash',
+
+  // Inspect and report; the verification command is theirs to run.
+  reviewer: 'readonly-bash',
+
+  // Inspect and report only.
+  'landing-critic': 'readonly',
+
+  // Write its rationale artifact, nothing else.
+  'ux-planner': 'write-only',
+};
+
+// What each capability permits, in host-neutral terms. Hosts that can't
+// enforce a per-agent grant state these as constraints in the agent's
+// prompt instead — `hedgehog verify` is what actually gates the commit,
+// by checking touched files against the packet's ALLOWED SCOPE.
+/** @type {Record<Capability, { read: boolean, write: boolean, run: boolean, summary: string }>} */
+export const CAPABILITY_GRANT = {
+  full: {
+    read: true,
+    write: true,
+    run: true,
+    summary: 'Read, write, and edit files, and run shell commands.',
+  },
+  'no-bash': {
+    read: true,
+    write: true,
+    run: false,
+    summary: 'Read, write, and edit files. Do not run shell commands.',
+  },
+  'readonly-bash': {
+    read: true,
+    write: false,
+    run: true,
+    summary:
+      'Read files and run shell commands. Do not write or edit any file — report findings as text.',
+  },
+  readonly: {
+    read: true,
+    write: false,
+    run: false,
+    summary:
+      'Read files only. Do not write or edit any file, and do not run shell commands — report findings as text.',
+  },
+  'write-only': {
+    read: true,
+    write: true,
+    run: false,
+    summary:
+      'Read files, and write only this role\'s own artifact. Do not run shell commands.',
+  },
+};
+
+// The capability for one agent, by `name` frontmatter. Unknown agents get
+// the most restrictive grant rather than the most permissive one, so a new
+// agent added without a table entry fails closed.
+export function capabilityFor(agentName) {
+  return AGENT_CAPABILITY[agentName] ?? 'readonly';
+}
+
+export function grantFor(agentName) {
+  return CAPABILITY_GRANT[capabilityFor(agentName)];
+}

package/src/hosts/claude/DISPATCH.md

@@ -0,0 +1,9 @@
+## Delegating on this host
+
+The agents in `.claude/agents/` are registered automatically — delegate to
+one by name (`backend-eng`, `reviewer`, and so on) and it runs in its own
+context with its own tool grant. The skills in `.claude/skills/` are
+available the same way; invoke one by name rather than reimplementing what
+it describes.
+
+Clear context with `/clear` at the unit boundaries described above.

package/src/hosts/cursor/DISPATCH.md

@@ -0,0 +1,16 @@
+## Delegating on this host
+
+The agent files in `.cursor/agents/` are the roles this build uses. To run
+one, read its file and follow it for that task, passing the `hedgehog
+next` packet in full. Where a subagent is available, pass the file's
+entire body as that subagent's prompt — the file is the role.
+
+Each agent file opens with the tools that role may use. Honor it: Cursor
+grants tools per session, so the constraint is yours to keep. `hedgehog
+verify` checks the touched files against the packet's ALLOWED SCOPE and
+gates the commit either way.
+
+The skills in `.cursor/skills/` are procedures to follow — read the one
+whose situation applies rather than improvising the steps.
+
+Clear the conversation at the unit boundaries described above.

package/src/hosts/cursor/hedgehog.mdc

@@ -0,0 +1,20 @@
+---
+description: Hedgehog build discipline — how to work in this repo
+alwaysApply: true
+---
+
+This project is built with Hedgehog: one small, tested, committed step at
+a time. State lives in the build graph (`.hedgehog/hedgehog.db`), the
+commit log, and the code.
+
+Start every session with `hedgehog status`, then `hedgehog next` for the
+task packet of one ready step. When the work is done, `hedgehog verify
+<task-id>` checks the touched files against the packet's ALLOWED SCOPE,
+runs the verification command, and on a pass writes the commit. A task
+moves only on a passing `hedgehog verify`.
+
+- `HEDGEHOG.md` — this project's own context and its core's build order.
+- `AGENTS.md` — the index of every agent and skill, and when each applies.
+- `.cursor/agents/` — the roles. Read the file and follow it for that
+  task, passing the packet in full.
+- `.cursor/skills/` — procedures to follow when their situation applies.

package/src/hosts/emit.mjs

@@ -0,0 +1,23 @@
+// Rewrites a canonical agent file for a host that carries the role in a
+// prompt rather than registering it with its own tool grant.
+//
+// `model:`, `color:`, and `tools:` are Claude Code's subagent schema.
+// Elsewhere the role travels as text, so those keys come off and the tool
+// grant is restated as a line the agent reads — the same fact in the form
+// that host can act on. `hedgehog verify` gates the commit on ALLOWED
+// SCOPE regardless.
+
+import { parse, stringify } from './frontmatter.mjs';
+import { grantFor } from './capabilities.mjs';
+
+const CLAUDE_ONLY = ['model', 'color', 'tools'];
+
+export function emitPromptAgent(text) {
+  const { data, body } = parse(text);
+  const kept = { ...data };
+  for (const key of CLAUDE_ONLY) delete kept[key];
+
+  const grant = grantFor(data.name);
+  const constraint = `**Tools for this role:** ${grant.summary}\n\n`;
+  return stringify(kept, `\n${constraint}${body.replace(/^\n+/, '')}`);
+}

package/src/hosts/frontmatter.mjs

@@ -0,0 +1,48 @@
+// Minimal YAML frontmatter reader/writer for the agent and skill files.
+//
+// The payload's frontmatter is a flat block of `key: value` scalars — no
+// nesting, no lists, no anchors — so a full YAML parser would be a
+// dependency bought for nothing. This handles exactly that shape and
+// leaves the body untouched.
+
+const FENCE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
+
+/** Split a file into its frontmatter object and its body. */
+export function parse(text) {
+  const m = text.match(FENCE);
+  if (!m) return { data: {}, body: text };
+
+  const data = {};
+  for (const line of m[1].split(/\r?\n/)) {
+    // `description:` values routinely contain colons, so split on the
+    // first one only.
+    const at = line.indexOf(':');
+    if (at === -1 || line.startsWith('#')) continue;
+    const key = line.slice(0, at).trim();
+    let value = line.slice(at + 1).trim();
+    if (
+      (value.startsWith('"') && value.endsWith('"')) ||
+      (value.startsWith("'") && value.endsWith("'"))
+    ) {
+      value = value.slice(1, -1);
+    }
+    if (key) data[key] = value;
+  }
+  return { data, body: text.slice(m[0].length) };
+}
+
+// Quote only when a value would otherwise change meaning as bare YAML.
+// Descriptions commonly contain `: ` and `#`, both of which need it.
+function scalar(value) {
+  const s = String(value);
+  const needsQuote = /:\s|^\s|\s$|^[[{>|*&!%@`'"]|#\s|\r|\n/.test(s) || s === '';
+  return needsQuote ? `"${s.replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"` : s;
+}
+
+/** Rebuild a file from a frontmatter object and a body, key order preserved. */
+export function stringify(data, body) {
+  const lines = Object.entries(data)
+    .filter(([, v]) => v !== undefined && v !== null)
+    .map(([k, v]) => `${k}: ${scalar(v)}`);
+  return `---\n${lines.join('\n')}\n---\n${body}`;
+}

package/src/hosts/gemini/DISPATCH.md

@@ -0,0 +1,27 @@
+## Delegating on this host
+
+`invoke_agent` dispatches to a generalist — the role travels in the
+prompt. To delegate to an agent named in this file or in `AGENTS.md`:
+
+1. Read `.gemini/agents/<name>.md` in full.
+2. Call `invoke_agent` with `agent_name: "generalist"`, passing that
+   file's **entire body** as the prompt, followed by the `hedgehog next`
+   packet in full.
+
+The file is the role — pass it whole rather than summarizing it, and pass
+the packet rather than a step name.
+
+Independent steps can go out as several `invoke_agent` calls in one
+response. Steps that depend on each other stay sequential.
+
+Each agent file opens with the tools that role may use. A dispatched
+generalist keeps that constraint by reading it, and `hedgehog verify`
+checks the touched files against the packet's ALLOWED SCOPE before any
+commit lands.
+
+The skills in `.gemini/skills/` are procedures to follow — read the one
+whose situation applies rather than improvising the steps.
+
+Clear the conversation at the unit boundaries described above.
+
+@./AGENTS.md

package/src/hosts/gemini/gemini-extension.json

@@ -0,0 +1,6 @@
+{
+  "name": "hedgehog",
+  "version": "1.0.0",
+  "description": "Hedgehog build discipline: ordered, tested, verified build steps.",
+  "contextFileName": "GEMINI.md"
+}

package/src/hosts/index.mjs

@@ -0,0 +1,124 @@
+// The host registry: one entry per coding agent Hedgehog installs into.
+//
+// A host describes where the discipline's payload lands in a consuming
+// repo and, where the host's format differs from the canonical one, how
+// to emit it. `src/agents/` and `src/skills/` are the single source of
+// truth for content — a host adapts packaging, never substance.
+//
+// Adding a host means adding one entry here (and a matching directory
+// under src/hosts/<name>/ for whatever templates it needs).
+
+import { emitPromptAgent } from './emit.mjs';
+
+// Hosts that dispatch real subagents get the full discipline: each build
+// step runs in its own context with its own role. Hosts that don't are
+// still supported through the AGENTS.md routing doc, which indexes the
+// same agent and skill files for an agent to read inline. Either way
+// `hedgehog verify` is what gates a commit, so correctness does not
+// depend on the host's tool grants.
+
+/**
+ * @typedef {object} Host
+ * @property {string} agentsDir      where agent definitions land
+ * @property {string} skillsDir      where skill directories land
+ * @property {string} bootstrapFile  the project file this host auto-loads
+ * @property {(body: string, meta: object) => string} [emitAgent]
+ *   rewrites one agent file for this host. Omitted when the canonical
+ *   file is already in the host's format — the installer then copies it
+ *   verbatim, which is what keeps Claude Code output byte-identical.
+ * @property {Array<object>} [extraEntries] extra payload entries for this host
+ */
+
+// AGENTS.md is the convention a growing number of coding agents read
+// from a repo root. Every host ships it: it costs one generated file and
+// it means a second agent opening the project finds the discipline
+// without a second install.
+const routingDoc = (host) => ({
+  type: 'generated',
+  to: 'AGENTS.md',
+  // Indexes every host the project is set up for, not just the one being
+  // installed, so adding a second host doesn't strand the first one's
+  // paths.
+  generate: async ({ pkgRoot, projectRoot }) => {
+    const [{ renderAgentsMd }, { installedHosts }] = await Promise.all([
+      import('./routing.mjs'),
+      import('./installed.mjs'),
+    ]);
+    const recorded = projectRoot ? await installedHosts(projectRoot) : [];
+    const names = [...new Set([host, ...recorded])];
+    return renderAgentsMd({ pkgRoot, hosts: names.map((n) => HOSTS[n]) });
+  },
+});
+
+/** @type {Record<string, Host>} */
+export const HOSTS = {
+  // Claude Code reads src/agents/*.md and src/skills/ * /SKILL.md as
+  // authored — frontmatter and all — so it has no emitter. This is the
+  // canonical format every other host is adapted from.
+  claude: {
+    agentsDir: '.claude/agents',
+    skillsDir: '.claude/skills',
+    bootstrapFile: 'CLAUDE.md',
+    label: 'Claude Code',
+    get extraEntries() {
+      return [routingDoc('claude')];
+    },
+  },
+
+  // Cursor loads `.cursor/rules/*.mdc` on every request and reads
+  // AGENTS.md at the repo root. The rule points at both, the project's
+  // own context lives in HEDGEHOG.md, and the agent files carry their
+  // tool grant as a line of the prompt.
+  cursor: {
+    agentsDir: '.cursor/agents',
+    skillsDir: '.cursor/skills',
+    bootstrapFile: 'HEDGEHOG.md',
+    label: 'Cursor',
+    emitAgent: emitPromptAgent,
+    get extraEntries() {
+      return [
+        routingDoc('cursor'),
+        {
+          type: 'file',
+          from: 'src/hosts/cursor/hedgehog.mdc',
+          to: '.cursor/rules/hedgehog.mdc',
+        },
+      ];
+    },
+  },
+
+  // Gemini CLI loads GEMINI.md at session start and resolves its `@./`
+  // includes, so the routing doc comes in with it. `invoke_agent`
+  // dispatches an untyped generalist, so each agent file carries its
+  // tool grant as a line of the prompt it will be passed as.
+  gemini: {
+    agentsDir: '.gemini/agents',
+    skillsDir: '.gemini/skills',
+    bootstrapFile: 'GEMINI.md',
+    label: 'Gemini CLI',
+    emitAgent: emitPromptAgent,
+    get extraEntries() {
+      return [
+        routingDoc('gemini'),
+        {
+          type: 'file',
+          from: 'src/hosts/gemini/gemini-extension.json',
+          to: 'gemini-extension.json',
+        },
+      ];
+    },
+  },
+};
+
+// One install flag per host, named for the tool a user is asking to use.
+// Mirrors CORE_FLAGS in bin/cli.mjs: the public flag and the internal
+// name are allowed to diverge so the CLI surface can stay stable.
+export const HOST_FLAGS = {
+  '--claude': 'claude',
+  '--cursor': 'cursor',
+  '--gemini': 'gemini',
+};
+
+export const DEFAULT_HOST = 'claude';
+
+export const availableHosts = () => Object.keys(HOSTS).sort();

package/src/hosts/installed.mjs

@@ -0,0 +1,58 @@
+// Which hosts a project has Hedgehog installed for.
+//
+// `init` records them so `update` refreshes every host the project
+// actually uses without being told again. A project installed before
+// this file existed is read off the filesystem instead, by looking for
+// the directories each host's payload lands in.
+
+import { readFile, writeFile, mkdir, access } from 'node:fs/promises';
+import { constants } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { HOSTS, DEFAULT_HOST } from './index.mjs';
+
+const HOSTS_PATH = '.hedgehog/hosts.json';
+
+const exists = (p) =>
+  access(p, constants.F_OK).then(
+    () => true,
+    () => false,
+  );
+
+export async function recordHosts(root, hosts) {
+  const path = join(root, HOSTS_PATH);
+  const known = new Set(await readRecorded(root));
+  for (const h of hosts) known.add(h);
+  const merged = [...known].sort();
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, `${JSON.stringify({ hosts: merged }, null, 2)}\n`);
+  return merged;
+}
+
+async function readRecorded(root) {
+  try {
+    const { hosts } = JSON.parse(await readFile(join(root, HOSTS_PATH), 'utf8'));
+    return Array.isArray(hosts) ? hosts.filter((h) => h in HOSTS) : [];
+  } catch {
+    return [];
+  }
+}
+
+// A host counts as installed when its agents directory is on disk.
+async function detectHosts(root) {
+  const found = [];
+  for (const [name, h] of Object.entries(HOSTS)) {
+    if (await exists(join(root, h.agentsDir))) found.push(name);
+  }
+  return found;
+}
+
+/**
+ * The hosts `update` should refresh: what `init` recorded, else what's on
+ * disk, else the default.
+ */
+export async function installedHosts(root) {
+  const recorded = await readRecorded(root);
+  if (recorded.length) return recorded;
+  const detected = await detectHosts(root);
+  return detected.length ? detected : [DEFAULT_HOST];
+}

package/src/hosts/routing.mjs

@@ -0,0 +1,144 @@
+// Generates AGENTS.md — the routing doc for coding agents that read a
+// root instructions file but don't register Hedgehog's agents themselves.
+//
+// It is an *index*: every row points at the file that owns the
+// substance. The tables are built from each agent's and skill's own
+// `description` frontmatter, so a new agent or a reworded description
+// shows up here without this file being edited.
+
+import { readdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { parse } from './frontmatter.mjs';
+import { capabilityFor, CAPABILITY_GRANT } from './capabilities.mjs';
+
+// A description is a full paragraph aimed at a dispatcher deciding
+// whether to invoke this role. The table wants the trigger, so take the
+// first sentence and let the file itself carry the rest.
+function firstSentence(text = '') {
+  const flat = text.replace(/\s+/g, ' ').trim();
+  const end = flat.search(/\.\s|\.$/);
+  const out = end === -1 ? flat : flat.slice(0, end + 1);
+  return out.replaceAll('|', '\\|');
+}
+
+async function readEntries(dir, filename) {
+  const names = (await readdir(dir, { withFileTypes: true }))
+    .filter((e) => (filename ? e.isDirectory() : e.isFile() && e.name.endsWith('.md')))
+    .map((e) => e.name)
+    .sort();
+
+  const out = [];
+  for (const name of names) {
+    const path = filename ? join(dir, name, filename) : join(dir, name);
+    const { data } = parse(await readFile(path, 'utf8'));
+    if (!data.name) continue;
+    out.push({ ...data, file: filename ? `${name}/${filename}` : name });
+  }
+  return out;
+}
+
+export async function renderAgentsMd({ pkgRoot, hosts }) {
+  const agents = await readEntries(join(pkgRoot, 'src/agents'));
+  const skills = await readEntries(join(pkgRoot, 'src/skills'), 'SKILL.md');
+
+  // One project can be set up for several coding agents at once. Paths
+  // are quoted per host so whichever one is reading finds its own copy.
+  const dirs = (pick) =>
+    [...new Set(hosts.map(pick))].map((d) => `\`${d}\``).join(' or ');
+
+  const agentRows = agents
+    .map((a) => {
+      const grant = CAPABILITY_GRANT[capabilityFor(a.name)];
+      return `| \`${a.name}\` | ${firstSentence(a.description)} | ${grant.summary} | \`${a.file}\` |`;
+    })
+    .join('\n');
+
+  const skillRows = skills
+    .map((s) => `| \`${s.name}\` | ${firstSentence(s.description)} | \`${s.file}\` |`)
+    .join('\n');
+
+  return `# Working in this repo
+
+This project is built with **Hedgehog**, a one-step-at-a-time build
+discipline. The rules below aren't preferences — they're how the build
+stays mechanically correct.
+
+**State lives in the build graph (\`.hedgehog/hedgehog.db\`), the commit
+log, and the code.** A fresh session loses nothing: run \`hedgehog status\`
+and read the commit log to recover.
+
+## Start here
+
+\`\`\`bash
+hedgehog status    # what's built, what's ready, what's blocked
+hedgehog next      # the task packet for one ready step
+\`\`\`
+
+Agent files live in ${dirs((h) => h.agentsDir)}, and skills in
+${dirs((h) => h.skillsDir)}. The tables below name each file relative to
+those directories.
+
+If this project's instructions file still has unfilled \`{{PLACEHOLDER}}\`
+text, nothing has been built yet — read \`planner.md\` and run planning
+intake first.
+
+## The loop
+
+1. \`hedgehog next\` emits one task packet — STATUS, WHY NOW, BLOCKED
+   DOWNSTREAM, ALLOWED SCOPE, VERIFICATION. Trust it: a task is never
+   emitted unless every dependency is \`complete\`.
+2. Delegate the **full packet** to the agent that owns that layer (see
+   the table below). Don't summarize it, and don't pass just a step name.
+3. When the work is done, run \`hedgehog verify <task-id>\`. It checks the
+   touched files against ALLOWED SCOPE, runs the verification command,
+   and on a pass writes the commit and unlocks what the task blocked.
+
+**An agent reporting success never moves a task — only a passing
+\`hedgehog verify\` does.** This is the enforcement, and it holds no
+matter which coding agent you are or what tools you were granted.
+
+## Delegating
+
+If your harness dispatches subagents, read the agent's file and pass its
+**entire body** as that subagent's prompt, followed by the task packet.
+The file is the role — don't summarize it.
+
+If your harness has no subagent mechanism, read the agent's file and
+follow it yourself in this thread, then clear the conversation at the
+next unit boundary (a module's Phase A, a landing page section) and
+recover with \`hedgehog status\`.
+
+Either way, honor the "May" column below. Where a harness can't enforce a
+tool grant, the constraint is yours to keep — and \`hedgehog verify\` still
+gates the commit on ALLOWED SCOPE.
+
+## Agents
+
+| Agent | Use when | May | File |
+| --- | --- | --- | --- |
+${agentRows}
+
+## Skills
+
+Procedures to follow, not to improvise around. Read the file when its
+situation applies.
+
+| Skill | Use when | File |
+| --- | --- | --- |
+${skillRows}
+
+## CLI reference
+
+| Command | Does |
+| --- | --- |
+| \`hedgehog status\` | Every task, its state, and what it blocks |
+| \`hedgehog next\` | The task packet for one ready task |
+| \`hedgehog verify <task-id>\` | Gate a task: scope check, verification command, commit |
+| \`hedgehog why <path>\` | Which task and layer a file belongs to |
+| \`hedgehog plan\` | Compile intents into the task graph |
+| \`hedgehog intent add\` | Record an intent at planning intake |
+| \`hedgehog friction add "<note>"\` | Log build friction for later review |
+| \`hedgehog friction list\` | Read the friction log |
+| \`hedgehog graph\` | Live read-only diagram of the build graph |
+`;
+}

package/src/skills/hedgehog-bootstrap-full-stack-app-core/SKILL.md

@@ -88,8 +88,8 @@ natively-installed Postgres. See **Local infra: Docker, always** below.
 
 `hedgehog init --ts-full-stack-app` copies `src/golden-cores/full-stack-app/`
 to the repo root at install time, the same way it copies `src/agents` to
-`.claude/agents` — check whether the core files are already present
-(same check as step 1) before copying again. On a project that ran
+this host's own agents directory — check whether the core files are
+already present (same check as step 1) before copying again. On a project that ran
 plain `init` (no core flag) and only reaches `full-stack-app` because
 `planner` picked it at Phase 0, this hasn't happened yet: copy
 `src/golden-cores/full-stack-app/`'s contents to the repo root now. Also

package/src/skills/hedgehog-bootstrap-landing-page-core/SKILL.md

@@ -61,8 +61,8 @@ re-copy: patch the specific file at its source.
 
 `hedgehog init --landing-page` copies `src/golden-cores/landing-page/` to
 the repo root at install time, the same way it copies `src/agents` to
-`.claude/agents` — check whether the core files are already present
-(same check as step 1) before copying again. On a project that ran plain
+this host's own agents directory — check whether the core files are
+already present (same check as step 1) before copying again. On a project that ran plain
 `init` (no core flag) and only reaches `landing-page` because `planner`
 picked it at Phase 0, this hasn't happened yet: copy
 `src/golden-cores/landing-page/`'s contents to the repo root now. Also

package/src/templates/CLAUDE.md

@@ -105,10 +105,10 @@ context small:
 
 - **Clear context at natural boundaries** — a module's Phase A, a
   landing page section, whatever this core's own unit boundary is — once
-  that unit is done and committed. `/clear` and start fresh, then run
-  `hedgehog status`/`hedgehog next` and continue. Nothing is lost,
-  because the build graph, commits, and code hold all the state. Prefer
-  this over letting one session accumulate the entire project.
+  that unit is done and committed. Clear the conversation and start
+  fresh, then run `hedgehog status`/`hedgehog next` and continue. Nothing
+  is lost, because the build graph, commits, and code hold all the state.
+  Prefer this over letting one session accumulate the entire project.
 - **A cleared or new session recovers by running `hedgehog status` and
   reading the commit log**, never by needing the prior conversation.
 - **Delegate heavy work to agents.** Planning intake, scaffolding, and
@@ -119,3 +119,5 @@ context small:
   file's core section, not something to reconstruct. If you need a
   project specific, read it from the code. That's the self-documenting
   design working as intended.
+
+{{HOST_DISPATCH}}

package/src/templates/graph.html

@@ -75,6 +75,31 @@
     border-radius: 6px;
     font-size: 12px;
   }
+  #detail-panel .muted { color: #8b949e; font-size: 13px; }
+  #detail-panel ul.requirements {
+    margin: 4px 0 0;
+    padding-left: 0;
+    list-style: none;
+  }
+  #detail-panel ul.requirements li {
+    font-size: 13px;
+    padding: 6px 0;
+    border-bottom: 1px solid #21262d;
+  }
+  #detail-panel ul.requirements li:last-child { border-bottom: none; }
+  .req-kind {
+    display: inline-block;
+    font-size: 10px;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.03em;
+    padding: 1px 6px;
+    border-radius: 999px;
+    margin-right: 4px;
+  }
+  .req-kind-rule { background: #58a6ff33; color: #79c0ff; }
+  .req-kind-constraint { background: #d2992233; color: #e3b341; }
+  .req-kind-acceptance { background: #3fb95033; color: #56d364; }
   #legend {
     position: fixed;
     bottom: 16px;
@@ -173,6 +198,7 @@
 
   function DetailPanel({ task }) {
     if (!task) return h('div', { id: 'detail-panel' });
+    const requirements = task.requirements || [];
     return h(
       'div',
       { id: 'detail-panel', className: 'open' },
@@ -181,6 +207,26 @@
       h('div', null, task.intentGoal),
       h('div', { className: 'field-label' }, 'Objective'),
       h('div', null, task.objective),
+      // Every requirement kind together, same as hedgehog next's
+      // RELEVANT RULES — a task is bound by its rules, constraints, and
+      // acceptance criteria equally, so they read as one list rather
+      // than three separate sections.
+      h('div', { className: 'field-label' }, 'Requirements'),
+      requirements.length === 0
+        ? h('div', { className: 'muted' }, 'None recorded')
+        : h(
+            'ul',
+            { className: 'requirements' },
+            requirements.map((r, i) =>
+              h(
+                'li',
+                { key: i },
+                h('span', { className: `req-kind req-kind-${r.kind}` }, r.kind),
+                ' ',
+                r.statement,
+              ),
+            ),
+          ),
       h('div', { className: 'field-label' }, 'Verify command'),
       h('pre', null, task.verifyCommand),
       h('div', { className: 'field-label' }, 'Commit message'),