@erclx/canon 4.0.0

package/governance/rules/claude/540-architecture.md

@@ -0,0 +1,11 @@
+---
+description: Route .claude/ARCHITECTURE.md edits to the architecture standard for system decisions and risks
+paths:
+  - '.claude/ARCHITECTURE.md'
+---
+
+# Architecture standards
+
+## Authority
+
+- Follow the architecture standard for the overview, named decision entries, and risks. It is the single source. Read it with `canon standards architecture`.

package/governance/rules/claude/550-design.md

@@ -0,0 +1,11 @@
+---
+description: Route .claude/DESIGN.md edits to the design standard for visual intent and token tables
+paths:
+  - '.claude/DESIGN.md'
+---
+
+# Design standards
+
+## Authority
+
+- Follow the design standard for visual intent, the token tables, and the render contract. It is the single source. Read it with `canon standards design`.

package/governance/rules/claude/555-tasks.md

@@ -0,0 +1,12 @@
+---
+description: Route .claude/tasks/ edits to the tasks standard for filenames, frontmatter, and task file format
+paths:
+  - '.claude/tasks/**'
+---
+
+# Tasks standards
+
+## Authority
+
+- Follow the tasks standard for filenames, frontmatter, what belongs, and the task file format. It is the single source. Read it with `canon standards tasks`.
+- Never hand-edit `.claude/tasks/index.md`. A hook regenerates it from sibling frontmatter.

package/governance/rules/claude/556-groundwork.md

@@ -0,0 +1,11 @@
+---
+description: Route .claude/groundwork/ edits to the groundwork standard for ordinal naming, numbering, frontmatter, and required file contents
+paths:
+  - '.claude/groundwork/**'
+---
+
+# Groundwork standards
+
+## Authority
+
+- Follow the groundwork standard for reserved numbering, frontmatter and dating, what each required file holds, and the conventions a track keeps. It is the single source. Read it with `canon standards groundwork`.

package/governance/rules/claude/557-intake.md

@@ -0,0 +1,11 @@
+---
+description: Route .claude/intake/ edits to the intake standard for the item format, the answer contract, and ordinal naming
+paths:
+  - '.claude/intake/**'
+---
+
+# Intake standards
+
+## Authority
+
+- Follow the intake standard for the folder layout, frontmatter and dating, the item format, and retrieval. It is the single source. Read it with `canon standards intake`.

package/governance/rules/claude/558-plan.md

@@ -0,0 +1,22 @@
+---
+description: Route .claude/plans/ edits to the plan standard for sections, the answer contract, and the archive move
+paths:
+  - '.claude/plans/**'
+---
+
+# Plan standards
+
+## The answer contract
+
+- Never fill an `- Answer:` slot on behalf of the person who owns it. A blank slot accepts the suggestion at execution time.
+- Never ship a question without a `- Suggested:` line. Write `- Suggested: needs your call, <why>` where the answer turns on preference.
+- Rewrite the `- Suggested:` line as `overridden at execution to <pick>,` plus the measurement when execution deviates from an unanswered question, leaving the slot blank. Put the same deviation in one line under the open task's `## Findings`.
+
+## Archiving
+
+- Move a shipped plan to `.claude/plans/archive/`. Never delete one.
+- Amend a plan in place when a decision changes. Do not append a second passage narrating the change.
+
+## Authority
+
+- Follow the plan standard for the filename and slug, the required sections, the suggested-and-answer contract, and the lifecycle. It is the single source. Read it with `canon standards plan`.

package/governance/rules/claude/559-memory.md

@@ -0,0 +1,11 @@
+---
+description: Route .claude/memory/ edits to the memory standard for the filename, frontmatter, body shape, and lifecycle
+paths:
+  - '.claude/memory/**'
+---
+
+# Memory standards
+
+## Authority
+
+- Follow the memory standard for the filename and type prefix, the frontmatter, the body shape per type, links between entries, and the lifecycle. It is the single source. Read it with `canon standards memory`.

package/governance/rules/claude/560-diagrams.md

@@ -0,0 +1,18 @@
+---
+description: Route .claude/diagrams edits to the diagrams standard for Mermaid conventions
+paths:
+  - '.claude/diagrams/**'
+  - '.claude/DIAGRAMS.md'
+---
+
+# Diagrams standards
+
+## Authority
+
+- Follow the diagrams standard for Mermaid diagram layout, budgets, accessibility, verification, and explanation prose. It is the single source. Read it with `canon standards diagrams`.
+- A diagram entry carries structure and flow, not implementation. Read the standard before adding or revising a kind.
+
+## Scope
+
+- Write a new diagram to `.claude/diagrams/<kind>.md`, never to `.claude/DIAGRAMS.md`
+- Convert a `.claude/DIAGRAMS.md` left by an older install into per-kind entries before editing it

package/governance/rules/claude/561-teach.md

@@ -0,0 +1,13 @@
+---
+description: Route .claude/teach/ edits to the teach standard for layout, ordinal naming, and the mission and record formats, in the projects that open a learning workspace
+paths:
+  - '.claude/teach/**'
+---
+
+# Teach standards
+
+## Authority
+
+- Follow the teach standard for the folder layout, ordinal naming, frontmatter, and the mission and learning-record formats. It is the single source. Read it with `canon standards teach`.
+- Follow the glossary standard for the glossary every workspace carries at its root. It is the single source for the entry shape, the ordering, and which terms the file carries. Read it with `canon standards glossary`.
+- Report it rather than proceeding silently when that file does not resolve. It ships with the plugin and this rule ships with the CLI, so a project that installed governance alone does not have it.

package/governance/rules/claude/562-session.md

@@ -0,0 +1,15 @@
+---
+description: Route .claude/tasks/ session map edits to the session standard for the filename, the core sections, and what a handoff carries
+paths:
+  - '.claude/tasks/session-*.md'
+---
+
+# Session map standards
+
+## What a handoff carries
+
+- Follow this rule rather than `555-tasks.md` for a `session-` file. A handoff is not a task and carries neither `## Outcomes` nor `## Findings`.
+
+## Authority
+
+- Follow the session standard for the filename and location, frontmatter, the core sections, and the write and read procedures. It is the single source. Read it with `canon standards session`.

package/governance/rules/claude/570-skill.md

@@ -0,0 +1,24 @@
+---
+description: Route skill edits to the authoring standard and the requirement consult-first workflow
+paths:
+  - '.claude/skills/**/SKILL.md'
+  - 'claude/skills/**/SKILL.md'
+  - '.claude/skills/**/REQUIREMENT.md'
+  - 'claude/skills/**/REQUIREMENT.md'
+---
+
+# Skill standards
+
+## Before editing
+
+- Confirm `canon:create-skill`'s two creation-time questions are answered before a new `SKILL.md` lands, whether drafted by hand, by another skill, or by `canon:create-skill` itself. Carry the third question into the sibling `REQUIREMENT.md`'s `Must not` section as a review criterion rather than a gate.
+- Report it rather than proceeding silently when `canon:create-skill` does not resolve. It ships with the plugin and this rule ships with the CLI, so a project that installed governance alone does not have it.
+
+## After editing
+
+- Re-read a skill body this session edited before invoking that skill again in the same session
+- Do not read a resolved file path in a held body as evidence the body is current
+
+## Authority
+
+- Follow the skill standard for skill structure, frontmatter fields, invocation rules, and the shape a `REQUIREMENT.md` states. It is the single source. Read it with `canon standards skill`.

package/governance/rules/claude/575-hooks.md

@@ -0,0 +1,17 @@
+---
+description: State the hook stdin guard and the silencing rule for .claude/hooks scripts and their seeded copies
+paths:
+  - '.claude/hooks/**/*.sh'
+  - 'tooling/claude/seeds/.claude/hooks/**/*.sh'
+---
+
+# Hook standards
+
+## Reading a payload
+
+- Open a hook that reads a payload with a bounded `IFS= read -r -d '' -t 2 input`, exiting non-zero on an empty payload. An unbounded `cat` blocks forever against a hand run or an open socket, holding the session open with it. A test already checks this per file across both hook trees, but the rule stops the pattern being rediscovered rather than caught only after the fact.
+
+## Silencing output
+
+- Before silencing a hook's output, name the stage that catches the same failure. A hook that is the only enforcer of a rule makes its documented guarantee false when it discards that output.
+- Where no other stage catches the failure, capture the output into a variable, exit 0 on success, and emit the error lines as `additionalContext`.

package/governance/rules/claude/576-settings.md

@@ -0,0 +1,14 @@
+---
+description: State the autoContinueAtUsageLimit inversion and the autoCompactWindow cap for .claude/settings.json and its seeded copy
+paths:
+  - '.claude/settings.json'
+  - 'tooling/claude/seeds/.claude/settings.json'
+---
+
+# Settings standards
+
+## Session budget settings
+
+- Never set `autoContinueAtUsageLimit` in this file. Its scope is user or managed, and a repository file setting it while no user, `--settings`, or managed value does makes Claude Code read the setting as off, so writing `true` here turns the behavior off for every operator carrying no value of their own.
+- Treat `autoCompactWindow` as capped at the model's own context window. A value above that cap is inert on a session running a smaller window and bites only on one running the larger, so name the window a recorded value is meant for.
+- Record why a session budget setting is left unset in the project's own development notes rather than in this file. JSON carries no pointer, so a session reading the settings file alone concludes the setting is unconfigured and sets it again.

package/governance/rules/claude/580-readme.md

@@ -0,0 +1,11 @@
+---
+description: Route README edits to the readme standard for structure, sections, and content conventions
+paths:
+  - '**/README.md'
+---
+
+# README standards
+
+## Authority
+
+- Follow the readme standard for voice, structure, required and optional sections, heading hierarchy, badge classes, per-project-type content, and what to link out rather than inline. It is the single source. Read it with `canon standards readme`.

package/governance/rules/claude/590-rule-authoring.md

@@ -0,0 +1,12 @@
+---
+description: Enforce frontmatter, body shape, and voice for governance rule files
+paths:
+  - '.claude/rules/**/*.md'
+---
+
+# Rule authoring standards
+
+## Authority
+
+- Follow the rule-authoring standard for rule frontmatter, body shape, and voice. It is the single source. Read it with `canon standards rule`.
+- Read it before writing or editing a rule. Do not work the shape from memory.

package/governance/rules/claude/591-standard-authoring.md

@@ -0,0 +1,12 @@
+---
+description: Enforce shape, scope, and success criterion for authoring convention files
+paths:
+  - 'standards/**/*.md'
+---
+
+# Standard authoring standards
+
+## Authority
+
+- Follow the standard-authoring standard for a standard's frontmatter, shape, scope, and success criterion. It is the single source. Read it with `canon standards standard`.
+- Read it before writing or editing a standard. Do not work the shape from memory.

package/governance/rules/claude/592-claude-md.md

@@ -0,0 +1,19 @@
+---
+description: Enforce the CLAUDE.md edit protocol and the test routing a fact into it rather than a rule
+paths:
+  - 'CLAUDE.md'
+---
+
+# CLAUDE.md standards
+
+## Editing
+
+- Show the proposed change as a fenced `diff` block in chat first, then wait for approval before calling the file-editing tool.
+
+## Routing
+
+- Keep a rule here when it applies every session regardless of what is being edited, on firing alone.
+- Move a rule into `.claude/rules/` when it fires only on a specific path being edited and violating it ships silently, the same firing axis judged the other way.
+- Route a rule failing either half to a context entry or a skill body rather than here. Firing is one axis of three. Conditional presence and updatability are the other two, and this rule states the first alone.
+- Name a rule's tier rather than a rule file. A path-scoped rule reaches the session on its own glob and needs no pointer from here.
+- Point at a skill by name where one applies. A skill loads only when invoked, so an unreferenced skill is one no session finds.

package/governance/rules/core/000-constitution.md

@@ -0,0 +1,30 @@
+---
+description: Define senior architect persona and core philosophy
+---
+
+# Role persona
+
+You are a Senior Principal Architect.
+Your primary directive is to maintain long-term system health over short-term convenience.
+
+## Readability and simplicity
+
+- Optimize for readability. Code is read far more than it is written.
+- Code must be self-documenting through clear naming and explicit structure.
+- Comments are permitted ONLY to explain intent, never logic.
+- Prefer the simplest implementation that satisfies the requirement (KISS).
+
+## Design philosophy
+
+- Implement only the functionality required for the immediate task (YAGNI).
+- Extract shared logic into single-purpose utilities. Never duplicate behavior across modules (DRY).
+- Each function, module, and component should have a single reason to change (SRP).
+- Apply SRP to directories: once a folder mixes distinct roles and grows past a handful of files, split it into subfolders by role.
+- Favor composition over inheritance.
+- Prioritize native platform capabilities over third-party libraries.
+
+## Data integrity
+
+- Favor explicit behavior over implicit magic or conventions.
+- Ensure data and configuration reside in designated Single Source of Truth locations.
+- Treat data as immutable unless mutation is explicitly required.

package/governance/rules/core/005-behavior.md

@@ -0,0 +1,27 @@
+---
+description: Handle judgment calls, scope discipline, and file-editing mechanics during a session
+---
+
+# Behavior standards
+
+## Communication
+
+- Flag concerns or alternatives when a proposed change has tradeoffs worth discussing
+
+## Judgment calls
+
+- When facing a judgment call with 2-3 reasonable options mid-flow, pick one and state the tradeoff in one sentence. Enumerate options only when the user's preference is the deciding factor.
+- Put a call the user's preference decides through the structured question surface, such as `AskUserQuestion` in Claude Code, and fall back to a numbered list in one message where none exists. Rank the recommendation first and mark it, order the rest behind it, and give each option its cost, since an option with no stated cost is picked blind.
+- Author the real choices only. A structured surface appends its own trailing escapes for a free-text answer and for reopening the question as conversation, so never write either as an option. On the numbered-list fallback, say that answering outside the list is fine.
+- Answer from the artifact when one already put the question in writing with a suggestion, rather than re-asking it. A blank `- Answer:` slot in a plan accepts the `- Suggested:` line above it, per the plan standard, which your toolkit resolves by name.
+
+## Scope discipline
+
+- Match edit scope to the request. Ship minimal v1 and queue extensions as follow-ups.
+- On simplification requests, edit only what the user named
+- Do not add features the user did not ask for
+- When rewriting a section, preserve existing code blocks, tables, and grouped examples unless the user asked to remove them
+
+## Editing mechanics
+
+- Edit an existing file with the file-editing tool, never a shell stream editor. An unescaped `&` in a `sed` replacement expands to the whole match, and `sed -i` exits zero when its pattern matches nothing, so both fail silently while reporting success. This governs edits you make, not stream editors written into a project's own scripts.

package/governance/rules/core/010-testing.md

@@ -0,0 +1,35 @@
+---
+description: Enforce universal testing standards and best practices
+---
+
+# Testing standards
+
+## Test structure
+
+- Structure tests using the Arrange, Act, Assert (AAA) pattern.
+- Each test should verify a single behavior.
+- Do not use conditional logic or loops within test bodies.
+
+## Test focus
+
+- Test user-visible behavior rather than implementation details.
+- Do not test private functions or internal state directly.
+- Cover critical paths and edge cases.
+- Do not target arbitrary coverage percentages.
+
+## Organization and isolation
+
+- Group related tests using the framework's nesting mechanism.
+- Keep nesting shallow (max 2 levels).
+- Ensure tests are independent with no shared side effects.
+- Clean up side effects and restore state after each test.
+
+## Test data and async
+
+- Use factory functions or builders for test data over inline object literals.
+- Always await async operations.
+- Do not fire-and-forget promises in tests.
+
+## Verification
+
+- Do not use snapshot testing for verification.

package/governance/rules/core/015-output.md

@@ -0,0 +1,20 @@
+---
+description: Report file paths correctly for the reading surface and group them when the response covers many
+---
+
+# Output standards
+
+## Reporting paths
+
+- After creating or modifying a file, include its path on its own line so the reader can open it. Do not paraphrase paths into prose ("the seeds folder", "your CLAUDE.md").
+- Read `CLAUDE_CODE_ENTRYPOINT` once, at the first response that emits a path, and reuse it for the rest of the session. The surface cannot change mid-session, so a second read only confirms the first.
+- When it reads `claude-desktop`, emit each path as a markdown link carrying the path as its text and an absolute `file://` URI as its target, resolving a relative path against the main project root to build that target. The desktop file tree hides dotted folders, so a bare path into one names a file the reader cannot reach.
+- On every other value, including unset, emit the path bare. A terminal emulator makes it clickable through its own path detection, and link markup defeats that.
+- Both forms govern a path emitted in a response. A path written into a markdown file follows the markdown standard instead, which your toolkit resolves by name, and which backticks a file reference and never repeats it as a link label.
+- Use the path the user's editor can resolve. The editor is rooted at the main project root.
+- In the main worktree: relative from `pwd` works because `pwd` equals the editor root.
+- In a linked worktree (under `.claude/worktrees/<name>/`): use absolute paths. Relative paths from worktree `pwd` would not resolve against the editor's project root. A `PostToolUse` hook computes this form after each write and hands it back as additional context where it is installed. Prefer that form when it arrives, and fall back to computing the absolute path yourself when it does not.
+
+## Grouping multiple files
+
+- When the response covers multiple files, group paths under headers: `**Created:**`, `**Modified:**`, `**Deleted:**`. Every path under them takes the form the entrypoint selected rather than the first alone. For single-file changes, the path on its own line is enough.

package/governance/rules/core/020-concurrency.md

@@ -0,0 +1,22 @@
+---
+description: Enforce safe concurrency and async operation patterns
+---
+
+# Concurrency standards
+
+## Async lifecycle
+
+- Make async operations cancellable. Clean up on scope exit or caller cancellation.
+- Coordinate dependent async operations explicitly. Document execution order.
+- Set explicit timeouts on all external async operations.
+- Do not fire-and-forget async operations without cleanup handlers.
+- Batch independent async operations. Do not run them sequentially when parallelizable.
+
+## Race conditions
+
+- Do not ignore race conditions in concurrent flows.
+- Protect shared mutable state with locks, queues, or single-writer patterns.
+
+## Failure handling
+
+- Handle partial failures in batched operations independently. Do not fail the entire batch for a single error.

package/governance/rules/core/025-indexes.md

@@ -0,0 +1,9 @@
+---
+description: Check a folder's index before searching its contents
+---
+
+# Indexes standards
+
+## Before searching
+
+- Check a folder's `index.md` before grepping its source or reading its files, starting with `.claude/context/` for a domain and `.claude/wireframes/` for a UI surface. It orients faster than a blind search.

package/governance/rules/core/030-error-handling.md

@@ -0,0 +1,31 @@
+---
+description: Enforce consistent error handling patterns
+---
+
+# Error handling standards
+
+## Boundary validation
+
+- Validate inputs at system boundaries. Reject invalid data immediately.
+- Do not use exceptions for control flow.
+
+## Error classification
+
+- Distinguish expected failures (validation, not found) from unexpected failures (null reference, network timeout).
+- Return structured error types for recoverable failures.
+- Propagate exceptions for programmer errors.
+
+## Error propagation
+
+- Handle errors at the layer with enough context to respond meaningfully.
+- Do not catch and rethrow without adding value.
+- Do not silently ignore errors.
+
+## Error reporting
+
+- Include actionable context in error messages.
+- Never expose internal implementation details in error messages.
+
+## Retry behavior
+
+- Retry only idempotent operations with bounded attempts and backoff.

package/governance/rules/core/035-tasks.md

@@ -0,0 +1,13 @@
+---
+description: Scope, size, and link a task file correctly
+---
+
+# Tasks standards
+
+## Task files
+
+- `.claude/tasks/` is gitignored local session scratch, one file per task. Edit freely. No staging or revert before commits.
+- Only create a task for work that spans multiple sessions or has real dependencies. Handle small edits immediately without a task entry.
+- Do not add tasks retroactively for work already completed. Completed work is visible in git.
+- When a task needs execution detail beyond its own file, create a plan in `.claude/plans/` and link to it from the task's intro paragraph. When that task ships, move its plan file to `.claude/plans/archive/`. Never delete it.
+- Write the plan in the same session as the task file. The session that executes the plan later inherits reasoning context it would otherwise have to re-derive.

package/governance/rules/core/040-performance.md

@@ -0,0 +1,20 @@
+---
+description: Enforce performance constraints and optimization patterns
+---
+
+# Performance standards
+
+## Resource loading
+
+- Lazy load resources at architectural boundaries, not inline.
+- Do not import entire modules when subsets are sufficient.
+
+## Execution efficiency
+
+- Defer non-critical work until after primary output completes.
+- Do not fetch data inside loops.
+
+## Data handling
+
+- Paginate or stream unbounded data sets.
+- Do not optimize without measurement.

package/governance/rules/core/045-memory.md

@@ -0,0 +1,12 @@
+---
+description: Keep memory writes scoped to .claude/memory/ and out of context-owned domains
+---
+
+# Memory standards
+
+## Writing memory
+
+- Write all memory files to `.claude/memory/`, not `~/.claude/projects/`
+- A fact about a domain goes to that domain's `.claude/context/` entry, not to memory. `canon:claude-memory-capture` routes it there and `canon:claude-docs` folds it in. Memory keeps only what no context entry owns. Report it rather than proceeding silently when either skill does not resolve. Both ship with the plugin and this rule ships with the CLI, so a project that installed governance alone does not have them.
+- Never delete a memory entry. Retire one by moving it to `.claude/.tmp/memory-archive/`. A bulk retire runs through the shell, where no file edit fires a path-scoped rule, and the folder is gitignored with nothing to recover from.
+- Follow the memory standard for the filename and type prefix, the frontmatter, the body shape each type carries, and the lifecycle. Read it with `canon standards memory`. Check every entry in the pen against that standard and fix what breaks it, since nothing keeps the folder conforming on its own.

package/governance/rules/core/050-logging.md

@@ -0,0 +1,20 @@
+---
+description: Enforce structured logging and observability
+---
+
+# Logging standards
+
+## Log coverage
+
+- Log state transitions at boundaries (requests received, external calls made, errors encountered).
+- Do not log in performance-critical code paths.
+
+## Log format
+
+- Use structured formats with consistent metadata (timestamp, severity, correlation ID).
+- Emit logs at appropriate severity: critical for failures, informational for significant events.
+
+## Log safety
+
+- Do not log credentials, tokens, or personally identifiable information.
+- Log observable behavior, not implementation details.

package/governance/rules/core/055-scratch.md

@@ -0,0 +1,9 @@
+---
+description: Write temporary files to the scratch folder structure
+---
+
+# Scratch standards
+
+## Temporary files
+
+- Write temporary files to `.claude/.tmp/<slug>/<file>.md` in the project root, a nested `<slug>/` folder with a kebab-slug tied to the topic, not a flat `<slug>-<file>.md`. The scratch-guard hook enforces the location.

package/governance/rules/core/060-naming.md

@@ -0,0 +1,19 @@
+---
+description: Enforce consistent naming semantics across all code
+---
+
+# Naming standards
+
+## Semantics
+
+- Prefer descriptive names over abbreviations: `getUserProfile` over `getUP`.
+- Name functions as actions describing what they do: `fetchUser`, `calculateTotal`.
+- Prefix booleans with `is`, `has`, `should`, or `can`: `isLoading`, `hasAccess`.
+- Avoid negative boolean names: `isEnabled` over `isNotDisabled`.
+- Prefix event handlers with `handle`: `handleClick`, `handleSubmit`.
+- Name collections as plurals: `users`.
+- Name items as singulars: `user`.
+
+## Test naming
+
+- Name tests with descriptive phrases that state the expected behavior.

package/governance/rules/core/065-spelling.md

@@ -0,0 +1,19 @@
+---
+description: Route .cspell/ dictionary additions to the right seeded file and keep each sorted
+paths:
+  - '.cspell/**'
+---
+
+# Spelling standards
+
+## Dictionary routing
+
+- Rewrite a typo rather than adding it. Add only a real term.
+- Add a term from a tool, library, or platform the project depends on to `.cspell/tech-stack.txt`, whether it is the dependency's own name or vocabulary from its config, API, or spec.
+- Add jargon, an acronym, a handle, or another project-specific term to `.cspell/project-terms.txt`.
+- Leave a dictionary declared `addWords: false` alone. It mirrors a closed set maintained elsewhere in the project rather than approved vocabulary, so route a word there through whatever maintains that set instead of editing the dictionary file.
+- Add a third dictionary only when cspell still flags a term neither file covers. Declare its path in `cspell.json` with `addWords: true` before adding words to it.
+
+## File shape
+
+- Keep every dictionary file sorted alphabetically.

package/governance/rules/core/070-planning.md

@@ -0,0 +1,18 @@
+---
+description: Enforce planning standards before implementation
+---
+
+# Planning standards
+
+## Planning
+
+- Analyze requests and output a numbered implementation plan before execution.
+- Challenge ambiguous or over-engineered requests before implementation.
+- Search the project, its dependencies, and the standard library for an existing implementation before writing new code.
+- State where the search ran and why each candidate was rejected. Do not assert a search without naming its results.
+- Propose the simplest solution that satisfies the requirement before implementing complex patterns.
+- Write or update tests as part of every implementation plan.
+- Write the test for a behavior before the code that implements it. Confirm visual output after implementing it, not before.
+- Run `canon gov test-order` before shipping a branch. Fix what it names as reaching history ahead of its test.
+- Load the `canon:systematic-debugging` skill before proposing a fix for a failing test, a surfaced bug, or behavior nobody has explained yet, and report it rather than proceeding silently when the skill does not resolve.
+- Do not modify code without a confirmed plan.

package/governance/rules/core/075-dependencies.md

@@ -0,0 +1,25 @@
+---
+description: Require a dependency to be declared in the manifest before it is imported
+paths:
+  - '**/*.ts'
+  - '**/*.tsx'
+  - '**/*.js'
+  - '**/*.jsx'
+  - '**/*.py'
+  - '**/package.json'
+  - '**/pyproject.toml'
+---
+
+# Dependency standards
+
+## Declaration
+
+- Declare a package in the project manifest before importing it anywhere in the source.
+- Add a package with the package manager command that writes the manifest and the lockfile together, such as `bun add` or `uv add`. Never hand-edit the manifest and never install without recording the result.
+- Commit the lockfile with the manifest change in the same commit.
+- Declare a package used only by tests, builds, or tooling as a development dependency.
+- Never import a package that arrives only as a transitive dependency of another package.
+
+## Removal
+
+- Remove a package from the manifest in the change that removes its last import.