From c9fddf13560490f4d4ac9e71f5158e5c6fa8f42e Mon Sep 17 00:00:00 2001 From: Erin Spencer Date: Sat, 6 Jun 2026 19:12:18 -0700 Subject: [PATCH 1/2] docs: clarify runner contract status --- AGENTS.md | 15 ++- CLAUDE.md | 22 ++-- ORG_DISTRIBUTION.md | 7 ++ README.md | 25 ++++- canon/SKILL.md | 73 ++++++++++++ cap-build/SKILL.md | 90 +++++++++++++++ deps-build/SKILL.md | 93 ++++++++++++++++ doc-build/SKILL.md | 90 +++++++++++++++ msdmd/SKILL.md | 7 +- owner-build/SKILL.md | 93 ++++++++++++++++ ratios/SKILL.md | 209 +++++++++++++++++++++++++++++++++++ risk-boundary-build/SKILL.md | 100 +++++++++++++++++ skills.json | 50 ++++++++- 13 files changed, 854 insertions(+), 20 deletions(-) create mode 100644 canon/SKILL.md create mode 100644 cap-build/SKILL.md create mode 100644 deps-build/SKILL.md create mode 100644 doc-build/SKILL.md create mode 100644 owner-build/SKILL.md create mode 100644 ratios/SKILL.md create mode 100644 risk-boundary-build/SKILL.md diff --git a/AGENTS.md b/AGENTS.md index 1ccdd21..9bdb8a1 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -38,14 +38,19 @@ the skill. Treat it as the public contract. 2. Parse the YAML frontmatter; index by `name` and `description`. 3. When a user request matches the triggers in a `description`, read that skill's full `SKILL.md` before acting. -4. Some skills (currently `msdmd`, `test-build`, `meta-module-build`) - define metadata blocks that other modules declare inside their own - source files. Other skills (currently `visitor-intro`) are purely - procedural and define no block. +4. Some skills (currently `msdmd`, `doc-build`, `cap-build`, `deps-build`, + `owner-build`, `test-build`, `meta-module-build`, `risk-boundary-build`, + and `ratios`) define metadata blocks that other modules declare inside their own source files. Other + skills (currently `canon` and `visitor-intro`) are purely procedural and + define no block. A machine-readable index is also available at `skills.json` if you prefer not to walk the tree. +This repo ships the universal msdmd parser implementations plus skill +specifications. Treat per-skill runner sections as contracts for consuming +repos unless the skill directory includes an actual helper script. + ## How to install this lib into another repo The canonical install path inside a consuming repo is: @@ -72,6 +77,8 @@ propagate from here. metadata block declared via `msdmd`. - New module work in any repo should start with a `MODULE_BUILD` block; see `meta-module-build/SKILL.md`. +- If you are deciding whether repo-local practice should become org doctrine, + load `canon/SKILL.md` and keep unsupported claims as `hmmm`. - If you are an agent introducing a newcomer to the org, load `visitor-intro/SKILL.md` and follow its output rubric. diff --git a/CLAUDE.md b/CLAUDE.md index 2293157..c0ca3ed 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -44,8 +44,15 @@ Skills present: | Skill | Kind | Depends on | Purpose | |---|---|---|---| | `msdmd/` | metadata-block | — | Foundational convention. Defines the comment-block syntax, the parser contract, the runner protocol, reserved field names, and the visible gap-reporting requirement. Ships reference parsers under `msdmd/parsers/`. Every metadata-block skill builds on it. | +| `doc-build/` | metadata-block | `msdmd` | Self-declaring documentation coverage. Modules declare `# === DOCS ===` blocks; a runner verifies documentation paths/anchors and reports stale docs plus visible gaps. | +| `cap-build/` | metadata-block | `msdmd` | Self-declaring capability inventory. Modules declare `# === CAPABILITIES ===` blocks; a runner builds a capability map and verifies exposed surfaces. | +| `deps-build/` | metadata-block | `msdmd` | Self-declaring dependency topology. Modules declare `# === DEPENDENCIES ===` blocks; a runner builds import/call/capability graphs and reports unresolved edges, cycles, and visible gaps. | +| `owner-build/` | metadata-block | `msdmd`, `risk-boundary-build` | Self-declaring module stewardship. Modules declare `# === OWNERS ===` blocks; a runner reports unowned modules, unresolved owners, and review coverage gaps. | | `test-build/` | metadata-block | `msdmd` | Self-declaring contract tests. Each module declares a `# === CONTRACTS ===` block; a runner discovers and executes the referenced test functions and reports per-contract status plus modules with no CONTRACTS as coverage gaps. | | `meta-module-build/` | metadata-block | `msdmd` | Metadata-first module scaffolding. Each module declares a `# === MODULE_BUILD ===` block (manifest: surfaces, boundaries, tests, rollout, rollback) before implementation. New module work in any org repo is expected to start here. | +| `risk-boundary-build/` | metadata-block | `msdmd`, `meta-module-build` | Runtime risk and permission boundaries. Existing modules declare `# === BOUNDARIES ===` blocks for auth, storage, network, user-data, admin, and operational effects. | +| `ratios/` | metadata-block | `msdmd` | Self-declaring module composition ratios. Each module records `loc_comments`, `imports_exports`, and `calls_definitions` in bookend `# === RATIOS ===` blocks; a runner recomputes values, fails on drift, and reports visible gaps. | +| `canon/` | procedural | — | Canonical-source and doctrine maintenance. Helps agents distinguish source-backed canon, proposed canon, repo-local practice, and `hmmm`. No metadata block. | | `visitor-intro/` | procedural | — | Onboarding tour. Lets any agent give a coherent, repo-aware orientation to newcomers at any org repo without inventing org-level facts. No metadata block. | --- @@ -71,12 +78,13 @@ of the skill. Keep it specific and list the triggers explicitly — do not bury ### Two kinds of skill -- **Metadata-block skills** apply the msdmd convention to a named block (`CONTRACTS`, - `MODULE_BUILD`, …). They define a field schema, a thin executor that consumes parsed +- **Metadata-block skills** apply the msdmd convention to a named block (`DOCS`, `CAPABILITIES`, `DEPENDENCIES`, `OWNERS`, `CONTRACTS`, + `MODULE_BUILD`, `BOUNDARIES`, `RATIOS`, …). They define a field schema, a thin executor that consumes parsed entries, and a runner that emits a visible gap list. `test-build/` is the canonical worked - example. `msdmd` itself is the foundation. + example; `doc-build/`, `cap-build/`, `deps-build/`, `owner-build/`, + `risk-boundary-build/`, and `ratios/` define adjacent applications. `msdmd` itself is the foundation. - **Procedural skills** define an agent behaviour with no msdmd block. They state the doctrine - they enforce and the output shape they produce. `visitor-intro/` is the example. + they enforce and the output shape they produce. `canon/` and `visitor-intro/` are the examples. ### The msdmd block syntax @@ -140,9 +148,9 @@ There is **no build, test, or lint tooling in this repository** — no `package. `pyproject.toml`, `Makefile`, or CI workflow. Do not invent commands. - The parsers are reference implementations; this repo does not ship a test suite for them. -- The runners shown in `test-build/SKILL.md` and described in `meta-module-build/SKILL.md` are - patterns for *consuming* repos to implement against their own source trees, not scripts that - live or run here. +- Runner sections in application SKILLs are contracts or patterns for *consuming* repos to + implement against their own source trees, not scripts that live or run here unless the skill + directory includes a helper file. - Validation here is editorial: keep `SKILL.md` frontmatter accurate, keep `skills.json` and the README table in sync with the directories present, and keep the parsers stdlib-only. diff --git a/ORG_DISTRIBUTION.md b/ORG_DISTRIBUTION.md index 3857037..153af1a 100644 --- a/ORG_DISTRIBUTION.md +++ b/ORG_DISTRIBUTION.md @@ -18,8 +18,15 @@ Propagation PRs should cite this repository and the source commit SHA. ## Installed skills * `msdmd/` — Module Self-Declared Metadata Markdown +* `doc-build/` — documentation coverage metadata blocks +* `cap-build/` — capability inventory metadata blocks +* `deps-build/` — dependency topology metadata blocks +* `owner-build/` — module stewardship metadata blocks * `test-build/` — contract-test metadata blocks * `meta-module-build/` — metadata-first module scaffolding +* `risk-boundary-build/` — runtime risk and permission boundary metadata blocks +* `ratios/` — module composition ratio verification +* `canon/` — canonical-source and doctrine maintenance * `visitor-intro/` — onboarding tour for newcomers landing at any org repo ## Target repos diff --git a/README.md b/README.md index ff3cbd4..b19c996 100644 --- a/README.md +++ b/README.md @@ -19,11 +19,23 @@ Agents consuming this lib should start at | Skill | Purpose | |---|---| -| [`msdmd/`](msdmd/SKILL.md) | The foundational convention. Defines the block syntax, parser contract, and visibility (gap-reporting) requirement. Every other skill in this lib depends on it. | +| [`msdmd/`](msdmd/SKILL.md) | The foundational convention. Defines the block syntax, parser contract, and visibility (gap-reporting) requirement. Every metadata-block skill in this lib depends on it. | +| [`doc-build/`](doc-build/SKILL.md) | Applies msdmd → documentation coverage. Modules declare `# === DOCS ===` blocks; a runner verifies documentation paths and anchors, reports stale docs, and surfaces visible gaps. | +| [`cap-build/`](cap-build/SKILL.md) | Applies msdmd → capability inventory. Modules declare `# === CAPABILITIES ===` blocks; a runner builds a capability map and verifies exposed surfaces. | +| [`deps-build/`](deps-build/SKILL.md) | Applies msdmd → dependency topology. Modules declare `# === DEPENDENCIES ===` blocks; a runner builds import/call/capability graphs, detects unresolved edges, and reports cycles. | +| [`owner-build/`](owner-build/SKILL.md) | Applies msdmd → module stewardship. Modules declare `# === OWNERS ===` blocks; a runner reports unowned modules, unresolved owners, and review coverage gaps. | | [`test-build/`](test-build/SKILL.md) | Applies msdmd → contract test runner. Each module declares its test contracts in a `# === CONTRACTS ===` block; the runner walks the tree, parses, runs them, and reports per-contract status plus visible coverage gaps. | | [`meta-module-build/`](meta-module-build/SKILL.md) | Applies msdmd → metadata-first module scaffolding. Each module declares its build manifest in a `# === MODULE_BUILD ===` block before implementation drifts into unscoped patches. | +| [`risk-boundary-build/`](risk-boundary-build/SKILL.md) | Applies msdmd → runtime boundary declarations. Modules declare `# === BOUNDARIES ===` blocks for auth, storage, network, user-data, admin, and operational effects. | +| [`ratios/`](ratios/SKILL.md) | Applies msdmd → module composition ratio verification. Each module records `loc_comments`, `imports_exports`, and `calls_definitions` in bookend `# === RATIOS ===` blocks that a runner recomputes and checks for drift. | +| [`canon/`](canon/SKILL.md) | Canonical-source and doctrine maintenance. Helps agents decide what is source-backed canon, proposed canon, or `hmmm` before changing skills or org doctrine. Independent of msdmd. | | [`visitor-intro/`](visitor-intro/SKILL.md) | Onboarding tour skill. Lets any agent give a coherent, repo-aware orientation to newcomers landing at any The-Interdependency repo, without inventing org-level facts. Independent of msdmd. | +|∆|Implementation status: this repo ships the universal msdmd parsers and skill +specifications. Most application skills define runner contracts for consuming +repos; they do not ship standalone executors here unless a helper file exists +in that skill directory.|∆| + ## The core idea Most "keep docs/tests/configs in sync with code" attempts rot because the @@ -63,19 +75,20 @@ authoritative spec. Skills come in two kinds. Pick the right one for what you're adding. **Metadata-block skills** apply the `msdmd` convention to a new block -name (`test-build`, `meta-module-build` are the existing examples). +name (`doc-build`, `cap-build`, `deps-build`, `owner-build`, `test-build`, `meta-module-build`, `risk-boundary-build`, `ratios` are the existing examples). To add one: 1. Pick a `` (e.g. `DOCS`, `CAPABILITIES`, `OWNERS`). 2. Decide the field schema (which fields are required, which optional). -3. Write a thin executor that takes parsed entries from - `msdmd/parsers/universal.py` and does something with them. -4. Author a `SKILL.md` that documents the convention and the executor. +3. Specify the runner/executor contract, or write a thin executor that takes + parsed entries from `msdmd/parsers/universal.py` and does something with + them. +4. Author a `SKILL.md` that documents the convention and runner behavior. `test-build/` is the canonical worked example. **Procedural skills** define an agent behaviour without an `msdmd` -block (`visitor-intro` is the existing example). To add one: +block (`canon` and `visitor-intro` are the existing examples). To add one: 1. Define when the skill loads (the `description` field in the YAML frontmatter is what your harness will read). diff --git a/canon/SKILL.md b/canon/SKILL.md new file mode 100644 index 0000000..1784140 --- /dev/null +++ b/canon/SKILL.md @@ -0,0 +1,73 @@ +--- +name: canon +description: Canonical-source and doctrine maintenance for The Interdependency skill library. Use this when deciding whether a claim, pattern, ratio, workflow, or repo-local practice should become canon; when moving source-backed behavior into a SKILL.md; when reconciling canonical skill-lib with repo-local `.agents/skills/` copies; or when preserving unresolved doctrine as `hmmm` instead of guessing. +--- + +# canon — Maintaining source-backed doctrine + +`canon` is a procedural skill for turning observed practice into honest, +source-backed doctrine. It protects the boundary between what the org has +actually made canonical and what an agent merely inferred. + +## Load this when + +- A user asks whether something should be canon. +- You are promoting a repo-local pattern into `skill-lib`. +- You are reconciling copied `.agents/skills/` directories with this repo. +- You are editing descriptions that decide when skills load. +- A claim is useful but not yet source-backed and needs a `hmmm` boundary. + +## Canon test + +Before writing a canonical claim, identify its backing class: + +| Class | Meaning | How to write it | +|---|---|---| +| `declared` | Already stated in this repo's README, AGENTS, ORG_DISTRIBUTION, skills.json, or a SKILL.md. | Cite or preserve directly. | +| `implemented` | Proven by code, parser behavior, runner behavior, or checked artifacts. | State only what the artifact does. | +| `repo-local` | Present in a target repo copy or local convention but not yet canonical here. | Name the repo-local source and avoid generalizing. | +| `inferred` | Reasonable conclusion but not declared or implemented. | Do not canonize; write `hmmm` or propose a decision. | +| `desired` | A design goal or request. | Mark as proposed until accepted into a skill. | + +|∆|Only `declared` and `implemented` claims are canon without qualification.|∆| +Repo-local and desired claims can motivate a skill change, but the skill must +say where the claim came from or leave the unresolved part as `hmmm`. + +## Canonization workflow + +1. **Find the source.** Prefer files in this repo. For repo-local copies, + record the repo/path/commit when available. +2. **Separate shape from meaning.** If examples show a pattern but do not + define semantics, canonize only the pattern and write semantic meaning as + `hmmm`. +3. **Choose the right home.** Foundational parser/block rules belong in + `msdmd`; application-specific blocks belong in their own skill; org + distribution rules belong in `ORG_DISTRIBUTION.md`; onboarding narrative + belongs in `visitor-intro`. +4. **Update indexes.** When adding a skill, update `skills.json`, README, + AGENTS, ORG_DISTRIBUTION, and CLAUDE when those files list installed skills. +5. **Preserve uncertainty.** Unknown fields and unresolved doctrine are + written `hmmm`, with enough context for the next agent to continue. +6. **Avoid retroactive authority.** Do not describe old repo-local practice as + canonical unless this repo adopts it in the same change. + +## Output rubric + +When answering canon questions, include: + +- **Canonical now:** source-backed facts. +- **Proposed canon:** useful changes that need acceptance or implementation. +- **hmmm:** unresolved constraints or missing sources. +- **Next patch:** the smallest change that makes the desired canon true. + +## Anti-patterns + +- Inferring semantics from examples and writing them as doctrine. +- Citing target-repo copies as source of truth after this repo has a contrary rule. +- Updating a skill without updating the machine-readable index. +- Treating `hmmm` as failure. It is the honest boundary object. + +hmmm +- whether canon claims should eventually live in a `CANON` metadata block +- whether target repo propagation should be verified by a dedicated runner +- whether accepted design chat should be archived as a source-backed artifact diff --git a/cap-build/SKILL.md b/cap-build/SKILL.md new file mode 100644 index 0000000..94a61c8 --- /dev/null +++ b/cap-build/SKILL.md @@ -0,0 +1,90 @@ +--- +name: cap-build +description: Self-declaring capability inventory built on msdmd. Each module declares the capabilities it exposes in a `# === CAPABILITIES ===` block; a runner builds a capability map, verifies referenced surfaces still exist, reports duplicate or missing capability declarations, and surfaces visible gaps. Load this when declaring what a module can do, when building capability registries for agents, or when auditing exposed surfaces against declared capabilities. +--- + +# cap-build — Capability declarations on msdmd + +`cap-build` is an application of [msdmd](../msdmd/SKILL.md). It gives +agents and humans a source-backed inventory of what modules can do, where +those capabilities are exposed, and which boundaries they cross. + +Implementation status: this skill defines the `CAPABILITIES` block and runner +contract. This repo does not currently ship a CAPABILITIES runner script; +consuming repos should implement the contract below against their own surfaces. + +Read `msdmd/SKILL.md` first if you have not. The block syntax, parser +contract, and visible gap rule are inherited. + +## The block + +```python +# === CAPABILITIES === +# id: agent_supervisor_dynamic_spawn +# summary: spawns child agents under a bounded supervisor +# exposes: AgentSupervisor.start_child/1 +# inputs: child_spec +# outputs: supervisor_child_ref +# boundaries: auth:none, storage:none, network:none, user_data:none +# owner: runtime-platform +# === END CAPABILITIES === +``` + +## Field schema + +Required: + +| Field | Meaning | +|---|---| +| `id` | Stable capability id. | +| `summary` | One-sentence capability description. | +| `exposes` | Function, class, route, command, UI component, or other public surface that exposes the capability; use `hmmm` if unresolved. | + +Optional: + +| Field | Meaning | +|---|---| +| `inputs` | Comma-separated input names or shapes. | +| `outputs` | Comma-separated output names or shapes. | +| `boundaries` | Comma-separated `name:value` boundary summary (`auth:none`, `storage:read`, etc.). Use `hmmm` for unresolved values. | +| `requires` | Comma-separated capability or module ids this capability depends on. | +| `class` | Free-text capability class (`runtime`, `ui`, `data`, `agent`, `ops`). | +| `owner` | Person, role, or team responsible for the capability. | +| `since` | Version or date the capability was added. | +| `deprecated` | If present, marks the capability as scheduled for removal. | + +## Runner contract + +A CAPABILITIES runner MUST: + +1. Parse every `CAPABILITIES` block with the universal msdmd parser. +2. Build a capability map keyed by `id`. +3. Report duplicate ids as errors. +4. Verify each non-`hmmm` `exposes` target still resolves when a resolver + exists for the language or framework. +5. Report unresolved `exposes: hmmm` and `boundaries` containing `hmmm` as + pending, not passing. +6. Report modules with exposed public surfaces but no CAPABILITIES block as + visible gaps when the runner can detect public surfaces. +7. Exit non-zero for duplicate ids, malformed required fields, or broken + resolvable exposure targets. Coverage gaps fail only in strict mode. + +## Reporting shape + +- `CAPABILITY`: id, summary, exposing module, owner, and boundaries. +- `BROKEN_EXPOSES`: declared surface no longer resolves. +- `DUPLICATE`: id appears more than once. +- `PENDING`: unresolved `hmmm` capability fields. +- `GAP`: public-looking modules or surfaces without capability metadata. + +## Anti-patterns + +- Declaring capabilities in a central registry while omitting the module-local block. +- Using implementation-shaped ids (`function_runs`) instead of capability-shaped ids (`agent_supervisor_dynamic_spawn`). +- Hiding boundary uncertainty; write `hmmm` where the effect is unresolved. +- Treating a module import as a capability without identifying the exposed behavior. + +hmmm +- exact resolver syntax for framework-specific route and UI surfaces +- whether capability ids should be globally unique across a repo or only within a block +- whether private capabilities deserve a separate block or a `class: internal` tag diff --git a/deps-build/SKILL.md b/deps-build/SKILL.md new file mode 100644 index 0000000..088047c --- /dev/null +++ b/deps-build/SKILL.md @@ -0,0 +1,93 @@ +--- +name: deps-build +description: Self-declaring dependency topology built on msdmd. Each module declares dependency edges it owns in a `# === DEPENDENCIES ===` block; a runner builds an import/call/capability graph, detects unresolved edges and cycles, and surfaces visible dependency coverage gaps. Load this when declaring module dependencies, auditing architecture drift, checking graph cycles, or wiring dependency topology checks into CI. +--- + +# deps-build — Dependency topology on msdmd + +`deps-build` is an application of [msdmd](../msdmd/SKILL.md). It makes a +module's dependency edges visible beside the code that creates them, so +architecture drift becomes inspectable instead of hidden in imports. + +Implementation status: this skill defines the `DEPENDENCIES` block and runner +contract. This repo does not currently ship a DEPENDENCIES graph runner; +consuming repos should implement the contract below with local resolvers. + +Read `msdmd/SKILL.md` first if you have not. The block syntax, parser +contract, and visible gap rule are inherited. + +## The block + +```python +# === DEPENDENCIES === +# id: chat_route_dependency_edges +# summary: chat API route depends on auth context and chat repository +# imports: auth.user_context, repositories.chat +# calls: ChatRepository.get_by_owner +# requires: auth_user_context, chat_repository +# class: runtime +# === END DEPENDENCIES === +``` + +## Field schema + +Required: + +| Field | Meaning | +|---|---| +| `id` | Stable dependency declaration id. | +| `summary` | One-sentence description of why these edges exist. | + +At least one edge field is required unless the entry records `hmmm`: + +| Edge field | Meaning | +|---|---| +| `imports` | Comma-separated modules/packages imported by this module. | +| `calls` | Comma-separated functions, methods, routes, commands, or capabilities called by this module. | +| `requires` | Comma-separated msdmd ids this module depends on. | +| `provides` | Comma-separated ids or surfaces this module provides to others. | +| `external` | Comma-separated external services, APIs, or packages this module depends on. | + +Optional: + +| Field | Meaning | +|---|---| +| `class` | Dependency class (`runtime`, `build`, `test`, `docs`, `ops`, `agent`). | +| `direction` | `inbound`, `outbound`, `bidirectional`, or `hmmm`. | +| `owner` | Person, role, or team responsible for this dependency shape. | +| `since` | Version or date the declaration was added. | +| `deprecated` | If present, marks an edge scheduled for removal. | + +## Runner contract + +A DEPENDENCIES runner MUST: + +1. Parse every `DEPENDENCIES` block with the universal msdmd parser. +2. Build a graph from `imports`, `calls`, `requires`, `provides`, and + `external` fields where resolvers exist. +3. Report unresolved non-`hmmm` edges as drift. +4. Report cycles in classes where cycles are disallowed by local policy. +5. Report modules with imports/calls but no DEPENDENCIES block as visible + coverage gaps when the runner can detect them. +6. Exit non-zero for malformed required fields, unresolved resolvable edges, + or forbidden cycles. Coverage gaps fail only in strict mode. + +## Reporting shape + +- `EDGE`: declared edge and source module. +- `UNRESOLVED`: declared edge no longer resolves. +- `CYCLE`: graph cycle detected. +- `PENDING`: edge or direction recorded as `hmmm`. +- `GAP`: dependency-bearing module without DEPENDENCIES metadata. + +## Anti-patterns + +- Treating an import list as architecture without explaining why edges exist. +- Declaring dependencies only in a central graph file. +- Hiding unresolved dependencies by omitting them; use `hmmm`. +- Failing all cycles blindly; some test or plugin graphs may intentionally cycle. + +hmmm +- exact resolver syntax for cross-language call and route edges +- which dependency classes disallow cycles by default +- whether package-manager dependencies should be declared here or only source-level edges diff --git a/doc-build/SKILL.md b/doc-build/SKILL.md new file mode 100644 index 0000000..e4b03a1 --- /dev/null +++ b/doc-build/SKILL.md @@ -0,0 +1,90 @@ +--- +name: doc-build +description: Self-declaring documentation coverage built on msdmd. Each module declares the public, developer, operator, or agent-facing documentation it owns in a `# === DOCS ===` block; a runner verifies linked docs and anchors exist, reports stale or missing documentation, and surfaces visible coverage gaps. Load this when adding or auditing module documentation, when tying code surfaces to docs, or when wiring documentation coverage checks into CI. +--- + +# doc-build — Documentation contracts on msdmd + +`doc-build` is an application of [msdmd](../msdmd/SKILL.md). It turns a +module's documentation obligations into colocated metadata so docs drift is +observable instead of discovered by surprise. + +Implementation status: this skill defines the `DOCS` block and runner contract. +This repo does not currently ship a DOCS runner script; consuming repos should +implement the contract below against their own documentation tree. + +Read `msdmd/SKILL.md` first if you have not. The block syntax, parser +contract, and visible gap rule are inherited. + +## The block + +Every module with user, developer, operator, or agent-facing behavior may +declare one or more documentation contracts: + +```python +# === DOCS === +# id: chat_api_public_docs +# summary: public documentation for creating and reading chat conversations +# audience: developer +# source: docs/chat.md#conversations +# covers: create_conversation, get_conversation +# status: current +# === END DOCS === +``` + +## Field schema + +Required: + +| Field | Meaning | +|---|---| +| `id` | Stable documentation contract id. | +| `summary` | One-sentence description of what the docs promise to explain. | +| `audience` | One of `user`, `developer`, `operator`, `agent`, `internal`, or `hmmm`. | +| `source` | Path to the documentation file, optionally with an anchor (`docs/file.md#heading`). Use `hmmm` if the target is not resolved yet. | +| `status` | `current`, `draft`, `deprecated`, or `hmmm`. | + +Optional: + +| Field | Meaning | +|---|---| +| `covers` | Comma-separated module surfaces, routes, functions, components, or concepts covered by the doc. | +| `examples` | Comma-separated example ids, files, or anchors the doc depends on. | +| `requires` | Comma-separated ids this documentation contract depends on. | +| `owner` | Person, role, or team responsible for doc freshness. | +| `since` | Version or date the contract was added. | + +## Runner contract + +A DOCS runner MUST: + +1. Parse every `DOCS` block with the universal msdmd parser. +2. Verify each non-`hmmm` `source` path exists. +3. If `source` includes an anchor, verify the target heading or anchor + exists when the file format supports anchors. +4. Report `status: draft` and `source: hmmm` as pending, not passing. +5. Report modules with no `DOCS` block as documentation coverage gaps. +6. Exit non-zero for missing files, missing anchors, malformed required + fields, or deprecated docs referenced as current. Coverage gaps fail only + in strict mode. + +## Reporting shape + +Normal output should group results as: + +- `PASS`: docs target exists and required fields are valid. +- `PENDING`: `hmmm` or `draft` documentation contracts. +- `DRIFT`: source path, anchor, or covered surface no longer resolves. +- `GAP`: source modules with no DOCS block. + +## Anti-patterns + +- Putting documentation ownership only in a separate docs index. +- Marking docs `current` when the source is `hmmm`. +- Treating missing DOCS blocks as invisible because the code has comments. +- Letting generated docs replace the source-owned declaration. + +hmmm +- whether examples listed in `examples` must execute or only resolve +- whether public exported surfaces without DOCS should fail strict mode by default +- how to normalize anchors across Markdown renderers diff --git a/msdmd/SKILL.md b/msdmd/SKILL.md index 9448aa3..c3b1a43 100644 --- a/msdmd/SKILL.md +++ b/msdmd/SKILL.md @@ -1,6 +1,6 @@ --- name: msdmd -description: Module Self-Declared Metadata in Markdown — the foundational convention where each source module declares its own structured metadata in a fenced comment block. Other skills in this lib (test-build, doc-build, cap-build, etc.) are thin applications on top of this convention. Load this when authoring a new metadata-driven skill, when extending the block schema, or when building a parser/executor for a new application. +description: Module Self-Declared Metadata in Markdown — the foundational convention where each source module declares its own structured metadata in a fenced comment block. Other skills in this lib (doc-build, cap-build, deps-build, owner-build, test-build, meta-module-build, risk-boundary-build, ratios, etc.) are thin applications on top of this convention. Load this when authoring a new metadata-driven skill, when extending the block schema, or when building a parser/executor for a new application. --- # msdmd — Module Self-Declared Metadata in Markdown @@ -183,7 +183,10 @@ their own SKILL.md. executor's behavior, and at least one worked example. `test-build/` is the canonical reference application. Read its -SKILL.md alongside this one to see the pattern fully realized. +SKILL.md alongside this one to see the pattern fully realized; read +`doc-build/`, `cap-build/`, `deps-build/`, `owner-build/`, +`risk-boundary-build/`, and `ratios/` for additional applications over +the same parser contract. ## Anti-patterns diff --git a/owner-build/SKILL.md b/owner-build/SKILL.md new file mode 100644 index 0000000..ac8f212 --- /dev/null +++ b/owner-build/SKILL.md @@ -0,0 +1,93 @@ +--- +name: owner-build +description: Self-declaring module stewardship built on msdmd. Each module declares who owns, reviews, and escalates changes in a `# === OWNERS ===` block; a runner reports unowned modules, unresolved `hmmm` owners, and missing review coverage for sensitive modules. Load this when assigning module ownership, routing reviews, auditing unowned code, or wiring stewardship coverage into CI. +--- + +# owner-build — Module stewardship on msdmd + +`owner-build` is an application of [msdmd](../msdmd/SKILL.md). It records +who is responsible for a module in the same file as the implementation, so +agents do not invent authority or edit sensitive code without a review path. + +Implementation status: this skill defines the `OWNERS` block and runner +contract. This repo does not currently ship an OWNERS runner script; consuming +repos should implement the contract below against their review policy. + +Read `msdmd/SKILL.md` first if you have not. The block syntax, parser +contract, and visible gap rule are inherited. + +## The block + +```python +# === OWNERS === +# id: chat_route_owner +# owner: platform-runtime +# steward: erin +# review_required_for: auth, storage, user_data +# escalation: platform-runtime +# since: 2026-06-04 +# === END OWNERS === +``` + +## Field schema + +Required: + +| Field | Meaning | +|---|---| +| `id` | Stable ownership declaration id. | +| `owner` | Person, role, team, or `hmmm` if unresolved. | + +Optional: + +| Field | Meaning | +|---|---| +| `steward` | Person or role currently tending the module; use `hmmm` if unresolved. | +| `review_required_for` | Comma-separated change classes requiring review (`auth`, `storage`, `network`, `user_data`, `admin`, `public_api`, `docs`, etc.). | +| `escalation` | Person, role, team, channel, or `hmmm` for unresolved escalation. | +| `backup_owner` | Secondary owner or team. | +| `requires` | Comma-separated ids whose ownership affects this module. | +| `since` | Version or date the owner declaration was added. | +| `deprecated` | If present, marks ownership as scheduled for replacement. | + +## Runner contract + +An OWNERS runner MUST: + +1. Parse every `OWNERS` block with the universal msdmd parser. +2. Report `owner: hmmm`, `steward: hmmm`, or `escalation: hmmm` as pending. +3. Report modules without OWNERS blocks as visible stewardship gaps. +4. Cross-check sensitive modules against `review_required_for` when + BOUNDARIES metadata is available. +5. Exit non-zero for malformed required fields or missing owners in strict + mode. Coverage gaps fail only in strict mode. + +## Agent behavior + +When this skill is loaded before edits: + +- Read OWNERS before making changes. +- If the intended edit touches a class named in `review_required_for`, call + out the review requirement in the handoff or PR summary. +- Do not replace `hmmm` with a guessed person, role, or team. +- If ownership is absent, preserve the gap in output rather than pretending + the committer or agent owns the file. + +## Reporting shape + +- `OWNED`: owner is declared. +- `PENDING`: owner, steward, or escalation is `hmmm`. +- `REVIEW_REQUIRED`: edit class requires explicit review. +- `GAP`: module has no OWNERS block. + +## Anti-patterns + +- Treating Git author, last committer, or PR opener as owner. +- Recording owner only in a central CODEOWNERS-like file while omitting the module-local declaration. +- Using ownership metadata to bypass review; it routes review, not permission. +- Guessing a team from a filename. Unknown is `hmmm`. + +hmmm +- whether repo-level CODEOWNERS should generate suggested OWNERS blocks +- whether strict mode should require owners for all modules or only public/sensitive ones +- how to represent temporary stewardship during incidents diff --git a/ratios/SKILL.md b/ratios/SKILL.md new file mode 100644 index 0000000..7e3c3cc --- /dev/null +++ b/ratios/SKILL.md @@ -0,0 +1,209 @@ +--- +name: ratios +description: Self-declaring module composition ratios built on msdmd. Each module records its own ratios (lines of code to lines commented, imports to exports, and calls to definitions) in a `# === RATIOS ===` block that bookends the file — first line and last line — and a runner recomputes each recorded ratio from the source and fails on drift, while reporting visible coverage gaps. Load this when recording a module's composition ratios, when authoring or extending the ratio registry, or when wiring ratio verification into CI. +--- + +# ratios — Module composition ratios on msdmd + +`ratios` is an application of [msdmd](../msdmd/SKILL.md). The foundational +skill defines the comment-block convention, the universal parser, and the +gap-reporting requirement; this skill applies the convention to a module's +own composition ratios and defines the executor contract. + +Implementation status: this skill defines the `RATIOS` block, registry, and +runner contract. This repo does not currently ship `ratios_check.py`; the CLI +below is the expected interface for a consuming repo's implementation. + +Read `msdmd/SKILL.md` first if you haven't — block syntax, the parser +contract, and the visibility rules below are inherited from there and not +redefined. + +A ratio is a fact a module owns about its own shape. Like a contract, it +belongs in the file it describes, not in a side report that can drift out +of sync. Unlike a contract, it is not asserted by a human — it is +*recomputed from the source*, so a recorded ratio that no longer matches +the file is a build failure, not a stale comment nobody noticed. + +## The block, and the bookend rule + +Every module records its ratios in a `RATIOS` block placed at **both +boundaries of the file** — the block is the literal first line and the +literal last line. The file is a self-measuring object; its boundary lines +carry the measurement, opening and closing. + +```python +# === RATIOS === +# id: loc_comments +# summary: lines of code to lines commented +# value: 141:40 +# basis: N = non-blank non-comment code lines; M = strict hash-comment + docstring lines; RATIOS block lines excluded +# +# id: imports_exports +# summary: import statements to public exports +# value: 8:5 +# basis: imports = lines matching ^(import |from \S+ import); exports = top-level def/class with no leading underscore + 1 if __all__ present; RATIOS block lines excluded +# +# id: calls_definitions +# summary: call sites to definitions +# value: 34:12 +# basis: definitions = top-level def + class lines; calls = non-definition lines containing a call expression \w+\(; RATIOS block lines excluded +# === END RATIOS === +``` + +The same block opens and closes the file. The parser iterates all matching +blocks, so the bookend is read from both ends; the runner verifies they +agree. + +## Field schema + +Required: + +| Field | Meaning | +|---|---| +| `id` | Ratio identifier, stable across refactors. Must match a computer in the registry to be *verified*; an id with no registered computer is recorded but unverifiable. | +| `value` | The recorded ratio as `A:B`, or `hmmm` if the ratio is declared-but-not-yet-resolved. | + +Optional: + +| Field | Meaning | +|---|---| +| `summary` | One-sentence human description. | +| `basis` | The counting rule used, in-band, so the recorded value is reproducible. Required in practice for any verified ratio whose definition admits a choice. | +| `class` | Free-text tag (`composition`, `coverage`, `complexity`). | +| `since` | Version or date the ratio was added. | +| `deprecated` | If present, the runner skips and reports the entry as deprecated. | + +## The registry and the verify contract + +A ratio is *verified* when its `id` maps to a computer in the runner's +registry. A computer is a pure function `file_text -> "A:B"`. The runner: + +- recomputes the ratio from the source, excluding the RATIOS block lines + themselves so a measuring block never inflates its own measurement; +- compares the recomputed value to the recorded `value`; +- on mismatch, emits a **drift** error and exits non-zero; +- on `value: hmmm`, reports a living continuation (pending), never a + failure — the transition out of `hmmm` is the owner's decision; +- on an id with no registered computer, reports it as recorded-but- + unverifiable (informational), so unknown ratios stay visible rather than + silently trusted. + +Files with no RATIOS block surface as coverage gaps, exactly as in the +build checker. The gap list is informational unless `--strict`. + +## The three ratios + +### 1. `loc_comments` — lines of code to lines commented + +`loc_comments` is `lines_of_code : lines_commented`. + +- **N (lines of code)**: physical lines carrying a code token — not blank, + not a pure comment, not a docstring-only line. Matches the `N` in the + a0p `# N:M` bookend annotation (`scripts/annotate.py`). +- **M (lines commented)**: strict `#`-comment lines plus docstring lines + (`"""` / `'''` blocks). Matches the `M` in `# N:M`. +- **self-exclusion**: lines inside any `=== RATIOS ===` … `=== END RATIOS ===` + fence are excluded from both counts. + +The `loc_comments` computer agrees with `scripts/annotate.py` by +construction — the same counting rule, so a file with a green `# N:M` +bookend will always produce a matching `loc_comments` value. + +Diagnostic signal: a ratio that drifts toward very high N:M (many code +lines, few comments) is approaching the 400-line code budget with low +documentation coverage. A ratio drifting toward very low N:M may indicate +grounding load — overhead accumulating faster than implementation. + +--- + +### 2. `imports_exports` — import statements to public exports + +`imports_exports` is `import_count : export_count`. + +- **import_count**: lines whose stripped content matches + `^(import |from \S+ import)`. Continuation lines of a multi-line import + are not counted separately — only the opening `import` / `from` line. +- **export_count**: count of top-level `def` and `class` declarations + whose names carry no leading underscore (public surface), **plus 1** if + `__all__` appears anywhere in the file (counts as one explicit export + declaration regardless of how many names it lists). +- **TypeScript / TSX**: import_count = lines matching `^import `; + export_count = lines carrying the `export ` keyword at the start + (excluding `export default` re-exports of imported names — those are + pass-through, not definitions). +- **self-exclusion**: RATIOS block lines excluded from both counts. + +Diagnostic signal: a high imports:exports ratio (many imports, few +public symbols) suggests the module is a consumer or orchestrator — low +surface, high dependency. A low ratio (few imports, many exports) suggests +a leaf module or utility layer. Neither is wrong; the ratio makes the +shape visible and detectable when it drifts unexpectedly. + +--- + +### 3. `calls_definitions` — call sites to definitions + +`calls_definitions` is `call_count : definition_count`. + +- **definition_count**: top-level `def` and `class` lines (all + visibility, not just public). Nested `def` inside a class counts as a + definition. Nested `def` inside another `def` (closures) does not count + — only one level of nesting beneath a class. +- **call_count**: non-definition, non-comment, non-blank lines containing + at least one call expression matching `\w+\(` — a word character + sequence immediately followed by `(`. Each physical line counts once + regardless of how many calls it contains. +- **self-exclusion**: RATIOS block lines excluded from both counts. + +Diagnostic signal: a very high calls:definitions ratio suggests a dense +orchestration file with few definitions and many invocations — close +coupling. A low ratio suggests mostly definitions with few call sites — +a library or schema module. Drift in this ratio across refactors signals +a module changing its architectural role. + +--- + +## The runner + +```bash +# verify one file's recorded ratios against its source +python ratios_check.py path/to/module.py + +# walk a tree, verifying every RATIOS block and listing files that have none +python ratios_check.py --root . + +# strict: files with no RATIOS block also fail (CI gate) +python ratios_check.py --root . --strict +``` + +Exit codes: `0` all recorded ratios match (gaps allowed unless `--strict`); +`1` a ratio drifted from source, or — under `--strict` — a coverage gap. + +## Anti-patterns + +- Recording a ratio by hand instead of recomputing it. The point is that + the file measures itself; a hand-typed value is a contract that drifts. +- Placing the block anywhere but the file boundaries. The bookend is the + convention; a mid-file RATIOS block defeats the at-a-glance reading. +- Counting the RATIOS block in its own ratio. Always self-exclude. +- Inventing ratio ids whose computer does not exist and recording a number + for them. If there's no computer, the value cannot be verified — record + `hmmm` until a computer is registered. +- Introducing a parser dialect for ratios. RATIOS is an ordinary msdmd + block; if richer syntax is needed, extend msdmd, do not fork it. +- Counting `export default` re-exports of imports as definitions in TS. + Pass-through re-exports are not definitions — they inflate the export + count without adding surface. + +## Completion criteria + +A run is complete when it produces either a SKILL-only declaration (the +convention, before any executor) or an executor plus a registry with all +three computers (`loc_comments`, `imports_exports`, `calls_definitions`) +registered and a passing self-verification on the files it covers. + +hmmm +- whether the bookend blocks must be byte-identical or may differ in whitespace +- whether ratios verification joins CI beside the MODULE_BUILD check +- calls_definitions: whether lambda assignments count as definitions +- imports_exports: whether re-exported names from __init__.py aggregate files count once or per-name diff --git a/risk-boundary-build/SKILL.md b/risk-boundary-build/SKILL.md new file mode 100644 index 0000000..c333bca --- /dev/null +++ b/risk-boundary-build/SKILL.md @@ -0,0 +1,100 @@ +--- +name: risk-boundary-build +description: Self-declaring runtime risk and permission boundaries built on msdmd. Each module records auth, storage, network, user-data, admin, and operational effects in a `# === BOUNDARIES ===` block; a runner audits sensitive files, reports unresolved `hmmm` boundaries, and surfaces visible coverage gaps. Load this when touching code with permissions, persistence, network calls, user data, admin behavior, migrations, or other risk-bearing effects. +--- + +# risk-boundary-build — Runtime boundaries on msdmd + +`risk-boundary-build` is an application of [msdmd](../msdmd/SKILL.md). It +turns hidden permission, storage, network, and user-data effects into +module-local declarations that can be reviewed before an agent edits a +sensitive file. + +This complements `meta-module-build`: MODULE_BUILD describes intended +boundaries before new work starts; BOUNDARIES records the actual runtime +boundary of an existing module. + +Implementation status: this skill defines the `BOUNDARIES` block and runner +contract. This repo does not currently ship a BOUNDARIES runner script; +consuming repos should implement the contract below with local risk heuristics. + +## The block + +```python +# === BOUNDARIES === +# id: chat_route_user_data_boundary +# summary: reads user-owned chat rows for the authenticated requester +# auth_boundary: read +# storage_boundary: read +# network_boundary: none +# user_data_boundary: read +# admin_only: false +# pii: possible +# owner: platform-runtime +# === END BOUNDARIES === +``` + +## Field schema + +Required: + +| Field | Meaning | +|---|---| +| `id` | Stable boundary declaration id. | +| `summary` | One-sentence description of the sensitive behavior. | +| `auth_boundary` | `none`, `read`, `write`, `admin`, or `hmmm`. | +| `storage_boundary` | `none`, `read`, `write`, `delete`, `migration`, or `hmmm`. | +| `network_boundary` | `none`, `internal`, `external`, or `hmmm`. | +| `user_data_boundary` | `none`, `read`, `write`, `delete`, or `hmmm`. | +| `admin_only` | `true`, `false`, or `hmmm`. | + +Optional: + +| Field | Meaning | +|---|---| +| `pii` | `none`, `possible`, `direct`, `sensitive`, or `hmmm`. | +| `secrets` | `none`, `read`, `write`, or `hmmm`. | +| `side_effects` | Comma-separated side effects (`email`, `webhook`, `billing`, `job`, `cache`, etc.). | +| `review_required` | Person, role, team, or condition required before edits. | +| `owner` | Person, role, or team responsible for the boundary declaration. | +| `requires` | Comma-separated BOUNDARIES or MODULE_BUILD ids this declaration depends on. | +| `since` | Version or date the declaration was added. | + +## Runner contract + +A BOUNDARIES runner MUST: + +1. Parse every `BOUNDARIES` block with the universal msdmd parser. +2. Report required fields containing `hmmm` as unresolved boundary objects. +3. Report modules with likely sensitive imports or filenames but no + BOUNDARIES block as visible gaps. +4. Support strict mode where gaps or any required `hmmm` boundary fail. +5. Exit non-zero for malformed required fields, invalid enum values, or + strict-mode unresolved boundaries. + +Sensitive-file heuristics MAY include auth/session imports, database clients, +network clients, migration filenames, admin routes, payment/billing modules, +secret managers, and user-data models. Heuristics are advisory: they create +review visibility, not proof of risk. + +## Agent behavior + +When this skill is loaded before editing code: + +- Read the BOUNDARIES block before changing implementation. +- If a required boundary is `hmmm`, preserve that uncertainty and call it out. +- Do not relax a boundary value (`admin` → `read`, `external` → `internal`, etc.) + unless the code change actually removes the effect. +- If the edit adds a new sensitive effect, update the block in the same diff. + +## Anti-patterns + +- Treating `none` as a default. Unknown is `hmmm`, not `none`. +- Recording intended boundaries in BOUNDARIES before code exists; use MODULE_BUILD first. +- Hiding risk in prose comments instead of structured fields. +- Letting heuristic gap detection replace explicit owner review. + +hmmm +- exact sensitive-import heuristic lists per framework +- whether strict mode should fail all `hmmm` boundaries or only user-data/admin ones +- how to represent read-only analytics on anonymized aggregate data diff --git a/skills.json b/skills.json index d74f8e5..2357fda 100644 --- a/skills.json +++ b/skills.json @@ -7,7 +7,35 @@ "name": "msdmd", "path": "msdmd/SKILL.md", "kind": "metadata-block", - "description": "Module Self-Declared Metadata in Markdown — the foundational convention where each source module declares its own structured metadata in a fenced comment block. Foundation for test-build, meta-module-build, and future msdmd applications." + "description": "Module Self-Declared Metadata in Markdown — the foundational convention where each source module declares its own structured metadata in a fenced comment block. Foundation for doc-build, cap-build, deps-build, owner-build, test-build, meta-module-build, risk-boundary-build, ratios, and future msdmd applications." + }, + { + "name": "doc-build", + "path": "doc-build/SKILL.md", + "kind": "metadata-block", + "depends_on": ["msdmd"], + "description": "Self-declaring documentation coverage built on msdmd. Modules declare DOCS blocks; a runner verifies documentation paths and anchors, reports stale or missing docs, and surfaces visible coverage gaps." + }, + { + "name": "cap-build", + "path": "cap-build/SKILL.md", + "kind": "metadata-block", + "depends_on": ["msdmd"], + "description": "Self-declaring capability inventory built on msdmd. Modules declare CAPABILITIES blocks; a runner builds a capability map, verifies exposed surfaces, reports duplicates, and surfaces visible gaps." + }, + { + "name": "deps-build", + "path": "deps-build/SKILL.md", + "kind": "metadata-block", + "depends_on": ["msdmd"], + "description": "Self-declaring dependency topology built on msdmd. Modules declare DEPENDENCIES blocks; a runner builds import/call/capability graphs, detects unresolved edges and cycles, and surfaces visible gaps." + }, + { + "name": "owner-build", + "path": "owner-build/SKILL.md", + "kind": "metadata-block", + "depends_on": ["msdmd", "risk-boundary-build"], + "description": "Self-declaring module stewardship built on msdmd. Modules declare OWNERS blocks; a runner reports unowned modules, unresolved hmmm owners, and review coverage gaps." }, { "name": "test-build", @@ -23,6 +51,26 @@ "depends_on": ["msdmd"], "description": "Metadata-first module build skill built on msdmd. Use when turning a capability idea into a bounded module manifest, file plan, public/internal surface, permission boundary, tests, docs, rollout, and rollback notes before implementation." }, + { + "name": "risk-boundary-build", + "path": "risk-boundary-build/SKILL.md", + "kind": "metadata-block", + "depends_on": ["msdmd", "meta-module-build"], + "description": "Self-declaring runtime risk and permission boundaries built on msdmd. Modules declare BOUNDARIES blocks for auth, storage, network, user-data, admin, and operational effects." + }, + { + "name": "ratios", + "path": "ratios/SKILL.md", + "kind": "metadata-block", + "depends_on": ["msdmd"], + "description": "Self-declaring module composition ratios built on msdmd. Records lines of code to lines commented, imports to exports, and calls to definitions in a RATIOS block; a runner recomputes values, fails on drift, and reports visible coverage gaps." + }, + { + "name": "canon", + "path": "canon/SKILL.md", + "kind": "procedural", + "description": "Canonical-source and doctrine maintenance for The Interdependency skill library. Load when deciding whether a claim, pattern, workflow, or repo-local practice should become canon, or when preserving unresolved doctrine as hmmm." + }, { "name": "visitor-intro", "path": "visitor-intro/SKILL.md", From 382e1ac04df99b735b0b656426615f96dc049a85 Mon Sep 17 00:00:00 2001 From: "openai-code-agent[bot]" <242516109+Codex@users.noreply.github.com> Date: Sun, 7 Jun 2026 02:26:19 +0000 Subject: [PATCH 2/2] docs: mention manifest skill in AGENTS Co-authored-by: wayseer00 <258336486+wayseer00@users.noreply.github.com> --- AGENTS.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/AGENTS.md b/AGENTS.md index 839ba8b..830ae3e 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -41,7 +41,7 @@ the skill. Treat it as the public contract. 4. Some skills (currently `msdmd`, `doc-build`, `cap-build`, `deps-build`, `owner-build`, `test-build`, `meta-module-build`, `risk-boundary-build`, and `ratios`) define metadata blocks that other modules declare inside their own source files. Other - skills (currently `canon` and `visitor-intro`) are purely procedural and + skills (currently `canon`, `char-compress`, `manifest`, and `visitor-intro`) are procedural and define no block. A machine-readable index is also available at `skills.json` if you