@hizliemre/horse-code 0.1.0 → 0.1.1

package/README.md

@@ -108,6 +108,27 @@ Facts an agent learns — a command that only works from a subdirectory, a file
 
 Each role is asked, at the close of its turn, whether anything cost it more than one attempt. That question is the difference between a run that learns and one that rediscovers.
 
+## Skills
+
+Six skills ship with the package. Each is a verbatim copy of its upstream, under `skills/`, in the same
+format a project uses for its own — the only difference is who supplies them, and a project may replace any
+of them by defining a skill of the same name in `.horsecode/skills/`.
+
+| | |
+|---|---|
+| `brainstorming` | intent and requirements before implementation — bound to the brainstormer |
+| `writing-plans` | what makes an individual task executable — bound to the task list |
+| `test-driven-development` | inlined into every role that writes code |
+| `frontend-design` | design direction, inlined into the design roles |
+| `systematic-debugging` | fetched on demand, when something is stuck |
+| `ui-ux-pro-max` | 161 palettes, 57 font pairings, 25 chart types across 10 stacks — fetched on demand |
+
+A skill can also be **referenced** rather than copied, for the ones that are large, script-driven, or
+maintained upstream. [`impeccable`](https://github.com/pbakaus/impeccable) ships that way: declared by
+default, installed by `/skills update` into `~/.horsecode/skills/`, and updatable from its source. Startup
+never waits on the network — installing is an explicit act. An explicitly stated `skillSources` list, an
+empty one included, replaces the shipped default entirely.
+
 ## Tools an agent has
 
 `read_file` `write_file` `edit_file` `grep` `glob` `shell` `git` (read-only) `git_write` `web_fetch` `ask_user` `remember_fact` `propose_memory` `skill` `find_tool` `find_unfinished`, plus the graph tools (`graph_overview`, `graph_find`, `graph_context`, `graph_impact`, `graph_trace`) and every tool exposed by a connected MCP server.

package/dist/{app-SB2L34JW.js → app-UGFQKMLX.js}

@@ -30,7 +30,7 @@ import "./chunk-HBSC2HT2.js";
 import "./chunk-FGVJFMK5.js";
 import {
   saveRoleSkills
-} from "./chunk-DKVIN43T.js";
+} from "./chunk-4EWK7HWQ.js";
 import {
   objectField,
   patchConfig
@@ -5570,7 +5570,7 @@ Question: ${question}` }
   };
   const addMcp = async (input) => {
     const { parseCommand, parseConfigBlock, extractFromPage, verify } = await import("./install-O34KMWJB.js");
-    const { saveMcpServer } = await import("./save-skills-OHYGVTQ4.js");
+    const { saveMcpServer } = await import("./save-skills-NSLBU33X.js");
     let cand = parseCommand(input) ?? parseConfigBlock(input);
     if (!cand) {
       const url = input.trim();

package/dist/chunk-4EWK7HWQ.js

@@ -0,0 +1,177 @@
+import {
+  arrayField,
+  objectField,
+  patchConfig
+} from "./chunk-H2FDGPVW.js";
+
+// src/config/config.ts
+import { z } from "zod";
+var UNSET_MODEL = "default";
+var DEFAULT_CONFIG = {
+  baseUrl: "http://localhost:20128",
+  model: UNSET_MODEL,
+  // acceptEdits: auto-approve file writes/edits (the pipeline builds in an isolated worktree → reviewed as a
+  // PR), still prompt for shell/exec. Keeps the automated build flowing without an approval per file.
+  mode: "acceptEdits",
+  allowlist: [],
+  roles: {},
+  specKit: { version: "v0.13.2" },
+  mcp: {},
+  modelSources: [],
+  traceDir: "",
+  /**
+   * Shipped as a REFERENCE, not a copy, for the reasons skills/README.md gives for exactly this shape: it is
+   * 3.3 MB across 154 files, it carries its own scripts, and it is maintained upstream. Vendoring it would
+   * freeze it at the commit it was taken on and turn every upstream fix into a manual merge — and it would
+   * multiply the published package by ten for a skill most runs never open.
+   *
+   * A default source is not an install. Startup stays offline; `/skills update` is the explicit act that
+   * fetches it, and a user who removes this entry from their own config is not overruled — the two configs
+   * merge by name.
+   */
+  skillSources: [{ name: "impeccable", repo: "pbakaus/impeccable", path: ".agents/skills/impeccable" }],
+  maxParallel: 8,
+  telemetry: true
+};
+var reviewerSchema = z.object({ name: z.string(), perspective: z.string(), models: z.array(z.string()) });
+var fileSchema = z.object({
+  apiKey: z.string().optional(),
+  baseUrl: z.string().optional(),
+  model: z.string().optional(),
+  mode: z.enum(["ask", "acceptEdits", "auto"]).optional(),
+  allowlist: z.array(z.string()).optional(),
+  roles: z.record(
+    z.string(),
+    z.object({
+      models: z.array(z.string()),
+      systemPrompt: z.string().optional(),
+      skills: z.array(z.string()).optional(),
+      // Anthropic models only — see RoleConfig.effort. Unknown keys are stripped, so without this line a
+      // level written into the config would be silently discarded on the way in.
+      effort: z.enum(["low", "medium", "high", "xhigh", "max"]).optional()
+    })
+  ).optional(),
+  // The review team's finder lenses, one set per stage (any omitted set falls back to the built-in default).
+  team: z.object({
+    spec: z.array(reviewerSchema).optional(),
+    plan: z.array(reviewerSchema).optional(),
+    code: z.array(reviewerSchema).optional()
+  }).optional(),
+  council: z.object({ members: z.array(reviewerSchema) }).optional(),
+  specKit: z.object({ version: z.string() }).optional(),
+  modelSources: z.array(z.string()).optional(),
+  traceDir: z.string().optional(),
+  // where /graph trace writes; empty = .horsecode/traces
+  mainBranch: z.string().optional(),
+  // the branch a resumed session syncs from; asked once, then remembered
+  // Bounded: below 1 nothing runs; above 32 the git merge lock, not the models, becomes the limit.
+  maxParallel: z.number().int().min(1).max(32).optional(),
+  telemetry: z.boolean().optional(),
+  skillSources: z.array(z.object({
+    name: z.string(),
+    repo: z.string(),
+    path: z.string().optional(),
+    ref: z.string().optional()
+  })).optional(),
+  mcp: z.record(
+    z.string(),
+    z.union([
+      z.object({ command: z.array(z.string()).min(1), env: z.record(z.string(), z.string()).optional(), readOnly: z.boolean().optional() }),
+      z.object({ url: z.string(), headers: z.record(z.string(), z.string()).optional(), readOnly: z.boolean().optional() })
+    ])
+  ).optional()
+}).partial();
+function parseFile(raw) {
+  if (!raw) return {};
+  try {
+    const parsed = fileSchema.safeParse(JSON.parse(raw));
+    return parsed.success ? parsed.data : {};
+  } catch {
+    return {};
+  }
+}
+function loadConfig(opts) {
+  const global = parseFile(opts.readFile(`${opts.home}/.horsecode/config.json`));
+  const project = parseFile(opts.readFile(`${opts.cwd}/.horsecode/config.json`));
+  const { apiKey: _leak, ...projectSafe } = project;
+  const merged = {
+    ...DEFAULT_CONFIG,
+    ...global,
+    ...projectSafe
+  };
+  merged.allowlist = projectSafe.allowlist ?? global.allowlist ?? [];
+  merged.roles = { ...global.roles ?? {}, ...projectSafe.roles ?? {} };
+  merged.mcp = { ...global.mcp ?? {}, ...projectSafe.mcp ?? {} };
+  merged.modelSources = projectSafe.modelSources ?? global.modelSources ?? [];
+  merged.maxParallel = projectSafe.maxParallel ?? global.maxParallel ?? DEFAULT_CONFIG.maxParallel;
+  merged.telemetry = projectSafe.telemetry ?? global.telemetry ?? DEFAULT_CONFIG.telemetry;
+  const spoken = global.skillSources !== void 0 || projectSafe.skillSources !== void 0;
+  const byName = new Map((spoken ? [] : DEFAULT_CONFIG.skillSources).map((s) => [s.name, s]));
+  for (const s of global.skillSources ?? []) byName.set(s.name, s);
+  for (const s of projectSafe.skillSources ?? []) byName.set(s.name, s);
+  merged.skillSources = [...byName.values()];
+  merged.specKit = projectSafe.specKit ?? global.specKit ?? DEFAULT_CONFIG.specKit;
+  const team = {
+    spec: projectSafe.team?.spec ?? global.team?.spec,
+    plan: projectSafe.team?.plan ?? global.team?.plan,
+    code: projectSafe.team?.code ?? global.team?.code
+  };
+  merged.team = team.spec || team.plan || team.code ? team : void 0;
+  const councilMembers = projectSafe.council?.members ?? global.council?.members;
+  merged.council = councilMembers ? { members: councilMembers } : void 0;
+  if (opts.env.OMNIROUTE_API_KEY) merged.apiKey = opts.env.OMNIROUTE_API_KEY;
+  if (opts.env.OMNIROUTE_BASE_URL) merged.baseUrl = opts.env.OMNIROUTE_BASE_URL;
+  return merged;
+}
+
+// src/config/save-skills.ts
+async function saveSkillSource(home, src) {
+  return patchConfig(home, (current) => {
+    if (current["skillSources"] === void 0) current = { ...current, skillSources: [...DEFAULT_CONFIG.skillSources] };
+    const sources = arrayField(current, "skillSources").filter(
+      (s) => !(typeof s === "object" && s !== null && s.name === src.name)
+    );
+    return { ...current, skillSources: [...sources, src] };
+  });
+}
+async function removeSkillSource(home, name) {
+  let found = false;
+  const ok = await patchConfig(home, (current) => {
+    const sources = arrayField(current, "skillSources");
+    const kept = sources.filter((s) => {
+      const match = typeof s === "object" && s !== null && s.name === name;
+      if (match) found = true;
+      return !match;
+    });
+    return found ? { ...current, skillSources: kept } : void 0;
+  });
+  return ok && found;
+}
+async function saveRoleSkills(home, assignments) {
+  const names = Object.keys(assignments);
+  if (!names.length) return 0;
+  const ok = await patchConfig(home, (current) => {
+    const roles = objectField(current, "roles");
+    for (const role of names) {
+      const prev = typeof roles[role] === "object" && roles[role] !== null ? roles[role] : {};
+      roles[role] = { ...prev, skills: [...assignments[role]] };
+    }
+    return { ...current, roles };
+  });
+  return ok ? names.length : 0;
+}
+async function saveMcpServer(home, name, spec) {
+  return patchConfig(home, (current) => ({
+    ...current,
+    mcp: { ...objectField(current, "mcp"), [name]: spec }
+  }));
+}
+
+export {
+  UNSET_MODEL,
+  loadConfig,
+  saveSkillSource,
+  removeSkillSource,
+  saveRoleSkills,
+  saveMcpServer
+};

package/dist/cli.js

@@ -42,8 +42,10 @@ import {
   parseFrontmatter
 } from "./chunk-BY4DP7IE.js";
 import {
+  UNSET_MODEL,
+  loadConfig,
   saveSkillSource
-} from "./chunk-DKVIN43T.js";
+} from "./chunk-4EWK7HWQ.js";
 import "./chunk-H2FDGPVW.js";
 import {
   buildBrief,
@@ -92,114 +94,6 @@ import { readFileSync as readFileSync3, existsSync as existsSync3, writeFileSync
 import { join as join8, dirname as dirname4 } from "path";
 import { pathToFileURL } from "url";
 
-// src/config/config.ts
-import { z } from "zod";
-var UNSET_MODEL = "default";
-var DEFAULT_CONFIG = {
-  baseUrl: "http://localhost:20128",
-  model: UNSET_MODEL,
-  // acceptEdits: auto-approve file writes/edits (the pipeline builds in an isolated worktree → reviewed as a
-  // PR), still prompt for shell/exec. Keeps the automated build flowing without an approval per file.
-  mode: "acceptEdits",
-  allowlist: [],
-  roles: {},
-  specKit: { version: "v0.13.2" },
-  mcp: {},
-  modelSources: [],
-  traceDir: "",
-  skillSources: [],
-  maxParallel: 8,
-  telemetry: true
-};
-var reviewerSchema = z.object({ name: z.string(), perspective: z.string(), models: z.array(z.string()) });
-var fileSchema = z.object({
-  apiKey: z.string().optional(),
-  baseUrl: z.string().optional(),
-  model: z.string().optional(),
-  mode: z.enum(["ask", "acceptEdits", "auto"]).optional(),
-  allowlist: z.array(z.string()).optional(),
-  roles: z.record(
-    z.string(),
-    z.object({
-      models: z.array(z.string()),
-      systemPrompt: z.string().optional(),
-      skills: z.array(z.string()).optional(),
-      // Anthropic models only — see RoleConfig.effort. Unknown keys are stripped, so without this line a
-      // level written into the config would be silently discarded on the way in.
-      effort: z.enum(["low", "medium", "high", "xhigh", "max"]).optional()
-    })
-  ).optional(),
-  // The review team's finder lenses, one set per stage (any omitted set falls back to the built-in default).
-  team: z.object({
-    spec: z.array(reviewerSchema).optional(),
-    plan: z.array(reviewerSchema).optional(),
-    code: z.array(reviewerSchema).optional()
-  }).optional(),
-  council: z.object({ members: z.array(reviewerSchema) }).optional(),
-  specKit: z.object({ version: z.string() }).optional(),
-  modelSources: z.array(z.string()).optional(),
-  traceDir: z.string().optional(),
-  // where /graph trace writes; empty = .horsecode/traces
-  mainBranch: z.string().optional(),
-  // the branch a resumed session syncs from; asked once, then remembered
-  // Bounded: below 1 nothing runs; above 32 the git merge lock, not the models, becomes the limit.
-  maxParallel: z.number().int().min(1).max(32).optional(),
-  telemetry: z.boolean().optional(),
-  skillSources: z.array(z.object({
-    name: z.string(),
-    repo: z.string(),
-    path: z.string().optional(),
-    ref: z.string().optional()
-  })).optional(),
-  mcp: z.record(
-    z.string(),
-    z.union([
-      z.object({ command: z.array(z.string()).min(1), env: z.record(z.string(), z.string()).optional(), readOnly: z.boolean().optional() }),
-      z.object({ url: z.string(), headers: z.record(z.string(), z.string()).optional(), readOnly: z.boolean().optional() })
-    ])
-  ).optional()
-}).partial();
-function parseFile(raw) {
-  if (!raw) return {};
-  try {
-    const parsed = fileSchema.safeParse(JSON.parse(raw));
-    return parsed.success ? parsed.data : {};
-  } catch {
-    return {};
-  }
-}
-function loadConfig(opts) {
-  const global = parseFile(opts.readFile(`${opts.home}/.horsecode/config.json`));
-  const project = parseFile(opts.readFile(`${opts.cwd}/.horsecode/config.json`));
-  const { apiKey: _leak, ...projectSafe } = project;
-  const merged = {
-    ...DEFAULT_CONFIG,
-    ...global,
-    ...projectSafe
-  };
-  merged.allowlist = projectSafe.allowlist ?? global.allowlist ?? [];
-  merged.roles = { ...global.roles ?? {}, ...projectSafe.roles ?? {} };
-  merged.mcp = { ...global.mcp ?? {}, ...projectSafe.mcp ?? {} };
-  merged.modelSources = projectSafe.modelSources ?? global.modelSources ?? [];
-  merged.maxParallel = projectSafe.maxParallel ?? global.maxParallel ?? DEFAULT_CONFIG.maxParallel;
-  merged.telemetry = projectSafe.telemetry ?? global.telemetry ?? DEFAULT_CONFIG.telemetry;
-  const byName = new Map((global.skillSources ?? []).map((s) => [s.name, s]));
-  for (const s of projectSafe.skillSources ?? []) byName.set(s.name, s);
-  merged.skillSources = [...byName.values()];
-  merged.specKit = projectSafe.specKit ?? global.specKit ?? DEFAULT_CONFIG.specKit;
-  const team = {
-    spec: projectSafe.team?.spec ?? global.team?.spec,
-    plan: projectSafe.team?.plan ?? global.team?.plan,
-    code: projectSafe.team?.code ?? global.team?.code
-  };
-  merged.team = team.spec || team.plan || team.code ? team : void 0;
-  const councilMembers = projectSafe.council?.members ?? global.council?.members;
-  merged.council = councilMembers ? { members: councilMembers } : void 0;
-  if (opts.env.OMNIROUTE_API_KEY) merged.apiKey = opts.env.OMNIROUTE_API_KEY;
-  if (opts.env.OMNIROUTE_BASE_URL) merged.baseUrl = opts.env.OMNIROUTE_BASE_URL;
-  return merged;
-}
-
 // src/skills/registry.ts
 import { readdir, readFile } from "fs/promises";
 import { join } from "path";
@@ -1256,7 +1150,7 @@ async function main(argv) {
   const useTui = shouldUseTui(!!process.stdin.isTTY, !!process.stdout.isTTY, !!args.noTui);
   if (!args.prompt) {
     if (useTui) {
-      const { runTuiRepl } = await import("./app-SB2L34JW.js");
+      const { runTuiRepl } = await import("./app-UGFQKMLX.js");
       const { fetchCatalog, makeProbe, discoverSources } = await import("./discover-5URG7C4J.js");
       const { loadSourceCache, saveSourceCache } = await import("./source-cache-XEK5WN7I.js");
       const manualSources = config.modelSources.length > 0;
@@ -1439,7 +1333,7 @@ _Committed with the repo, so every clone starts with them. Agents read one with
     ...args.revisionRounds !== void 0 && { revisionRounds: args.revisionRounds }
   };
   if (useTui) {
-    const { runTui } = await import("./app-SB2L34JW.js");
+    const { runTui } = await import("./app-UGFQKMLX.js");
     const res = await runTui({ buildDeps, job });
     console.log(renderResult(res));
     return;

package/dist/{save-skills-OHYGVTQ4.js → save-skills-NSLBU33X.js}

@@ -3,7 +3,7 @@ import {
   saveMcpServer,
   saveRoleSkills,
   saveSkillSource
-} from "./chunk-DKVIN43T.js";
+} from "./chunk-4EWK7HWQ.js";
 import "./chunk-H2FDGPVW.js";
 export {
   removeSkillSource,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hizliemre/horse-code",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Terminal coding agent: one sentence to reviewed, committed code — in its own git worktree",
   "license": "MIT",
   "author": "Emre Hızlı <hizliemre@gmail.com>",
@@ -32,7 +32,8 @@
     "node": ">=20"
   },
   "files": [
-    "dist"
+    "dist",
+    "skills"
   ],
   "scripts": {
     "build": "tsup",

package/skills/README.md

@@ -0,0 +1,123 @@
+# Bundled skills
+
+Every `SKILL.md` here is a **verbatim copy** from upstream:
+
+| skill | source | licence |
+|---|---|---|
+| `brainstorming` | superpowers 6.1.1 | plugin |
+| `test-driven-development` | superpowers 6.1.1 | plugin |
+| `writing-plans` | superpowers 6.1.1 | plugin |
+| `systematic-debugging` | superpowers 6.1.1 | plugin |
+| `frontend-design` | [anthropics/skills](https://github.com/anthropics/skills) | Apache-2.0 (`LICENSE.txt` shipped alongside) |
+| `ui-ux-pro-max` | ui-ux-pro-max-skill 2.0.1 | MIT © Next Level Builder (`LICENSE.txt` shipped alongside) |
+
+Do not edit them. Byte-identical is what makes them re-syncable when the upstream skill changes — a local
+tweak would either be silently overwritten on the next sync, or quietly diverge and stay.
+
+| skill | attached to | how |
+|---|---|---|
+| `brainstorming` | `brainstormer` | mandatory |
+| `test-driven-development` | `coder`, `senior-coder` | mandatory |
+| `writing-plans` | `project-manager` | mandatory |
+| `systematic-debugging` | — | discoverable |
+| `frontend-design` | `designer`, `senior-designer` | mandatory |
+| `ui-ux-pro-max` | — | discoverable |
+
+`ui-ux-pro-max` is discoverable rather than mandatory because of what it is: 43.7 KB of searchable database —
+161 palettes, 57 font pairings, 161 product types, 25 chart types — and not a method. `frontend-design` is the
+method the design roles need on every call, and it is small enough to inline. Paying 43.7 KB on every designer
+prompt for a lookup table most calls never open is the trade the discoverable listing exists to avoid.
+
+**Mandatory** skills are inlined into the role's system prompt (`applySkills`). **Discoverable** ones appear
+only as a one-line entry in the listing every role receives, and are fetched on demand with the `skill` tool —
+right for guidance that is only needed when something is stuck, and wasteful to inline into every prompt.
+
+## Where the horse-code specifics live
+
+Each skill describes a METHOD, and parts of it name conventions from its original habitat that do not exist
+here: `docs/superpowers/…` output paths, "dispatch a subagent", "invoke the writing-plans skill", a
+browser-based visual companion, TodoWrite task lists.
+
+Those are mapped onto this pipeline in the **role prompts** (`src/prompts.ts`), never by editing a skill:
+
+- the skill is the authority on *how the work is done*,
+- the role prompt is the authority on *where the output goes, what this pipeline already owns, and what
+  happens next*.
+
+Notably `writing-plans` is bound to the TASKS stage, not the plan stage. spec-kit's own `plan` template
+already governs `plan.md` (Technical Context, Constitution Check, Project Structure); a second competing
+template there would fight it. What spec-kit's *tasks* template does not supply is what makes an individual
+task executable — exact paths, a real test cycle, no placeholders — and that is what the skill contributes.
+
+## Overriding
+
+A project may replace any of these by defining a skill of the same name in `<project>/.horsecode/skills/`.
+Built-ins load first and the registry is keyed by name, so the project's version wins.
+
+## Dispatcher skills
+
+A skill may be a **dispatcher**: a small `SKILL.md` that routes to sibling documents ("see
+`reference/critique.md`"). The loader records each skill's directory, and the `skill` tool reads those
+documents on demand — `skill({name, file})`.
+
+On demand is the point. A dispatcher's entry point is small enough to sit in a prompt while its reference
+tree can run to megabytes; loading the tree up front would cost far more on every call than the guidance is
+worth on the rare call that needs it. Paths are contained to the skill's own directory and capped in size.
+
+## Installed from upstream, not copied
+
+A skill can also be **referenced** instead of vendored. Declare it in `config.skillSources`:
+
+```json
+"skillSources": [
+  { "name": "impeccable", "repo": "pbakaus/impeccable", "path": ".agents/skills/impeccable" }
+]
+```
+
+That entry is not an example: `impeccable` ships this way, declared in `DEFAULT_CONFIG.skillSources`. It is
+3.3 MB across 154 files and drives its own browser scripts, which is precisely the case this section
+describes — and vendoring it would have multiplied the published package by ten for guidance most runs never
+open.
+
+A default nobody can turn off would be a worse deal than no default, so an explicitly stated list wins
+outright, an empty one included. "No skill sources" and "never said" mean different things, and only the
+second falls back — the same distinction `saveRoleSkills` draws for role skills. Installing your first source
+writes the shipped ones into your config alongside it, so nothing disappears behind your back; removing one
+afterwards is then a real act with a real result.
+
+`/skills update` installs or refreshes them into `~/.horsecode/skills/<name>/` — outside this repo, because
+they are not ours. The commit is recorded beside each one, so an update knows whether anything actually
+changed and a re-run costs nothing when it has not.
+
+This is the right shape for a skill that is large, maintained upstream, or carries its own scripts. Copying
+one here would freeze it at the moment it was taken and make every upstream fix a manual merge. The whole
+subtree is installed, not just SKILL.md — a dispatcher's reference documents and any scripts it drives are
+part of the skill, and having them at a real path is what lets a script-driven skill run at all. Each skill's
+base directory is stated to the agent for exactly that reason.
+
+Startup never waits on the network: loading is offline, installing is an explicit act.
+
+**`impeccable`** is installed this way. It is not a prose skill — its SKILL.md dispatches to ~40 reference
+documents and drives its own `scripts/*.mjs`. It is discoverable rather than attached to a role: its own
+description says when it applies ("Not for backend-only or non-UI tasks"), and a 10 KB script-driven entry
+point does not belong in every designer prompt.
+
+## Still not adopted, and why
+
+- [`nextlevelbuilder/ui-ux-pro-max-skill`](https://github.com/nextlevelbuilder/ui-ux-pro-max-skill) (MIT) —
+  not one skill but seven, and two of them (`ui-styling` at 5.7 MB, `ui-ux-pro-max` at 1.7 MB) are libraries.
+  Cherry-picking a single self-contained one (e.g. `design-system`) is the only sane path.
+- [`AccessLint/skills`](https://github.com/AccessLint/skills) — a plugin of three skills that additionally
+  depend on an MCP server (`mcp__accesslint__*`) and the `@accesslint/cli`. It also carries **no licence**,
+  which has to be settled before any of it is vendored here.
+
+## Not adopted
+
+`using-git-worktrees`, `subagent-driven-development`, `executing-plans`, `dispatching-parallel-agents` and
+`finishing-a-development-branch` describe work this engine already does itself (worktree lifecycle, the wave
+engine, the review ladder, the PR flow). Shipping them would put two systems in charge of the same thing.
+
+`requesting-code-review` is likewise superseded: this pipeline runs its own staged review (per-stage finder
+lenses → council → judge).
+
+Only `SKILL.md` is read by the loader; every other file in these directories is documentation.