@freetesh/canon 0.0.0-stage → 0.16.0

package/cli/dist/standards.js

@@ -0,0 +1,42 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+const NOT_STANDARDS = new Set(["README.md"]);
+const PRINCIPLE = /^### (C-\d{2}) (.+)$/;
+function markdownIn(dir) {
+    return readdirSync(dir).filter((file) => file.endsWith(".md") && !NOT_STANDARDS.has(file));
+}
+/** canon's default standards, then each configured folder in order; a later file of the same name replaces an earlier one. */
+export function resolveStandards(canonRoot, folders) {
+    const byName = new Map();
+    const sources = [{ dir: join(canonRoot, "standards"), from: "canon" }, ...folders.map((dir) => ({ dir, from: dir }))];
+    for (const { dir, from } of sources) {
+        if (!existsSync(dir))
+            throw new Error(`standards folder not found: ${dir}`);
+        for (const file of markdownIn(dir)) {
+            const name = file.replace(/\.md$/, "");
+            // Constitutions add up (see constitutionTitles), so each one keeps its own entry.
+            const key = name === "constitution" ? `${name}:${from}` : name;
+            byName.set(key, { name, path: join(dir, file), from });
+        }
+    }
+    return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name) || Number(a.from !== "canon") - Number(b.from !== "canon"));
+}
+/**
+ * Principle headings from canon's constitution and every configured one. A
+ * constitution in a folder extends rather than replaces: it adds principles,
+ * and restating an ID rewords it.
+ */
+export function constitutionTitles(canonRoot, folders) {
+    const titles = new Map();
+    for (const dir of [join(canonRoot, "standards"), ...folders]) {
+        const file = join(dir, "constitution.md");
+        if (!existsSync(file))
+            continue;
+        for (const line of readFileSync(file, "utf8").split("\n")) {
+            const match = PRINCIPLE.exec(line);
+            if (match)
+                titles.set(match[1], `${match[1]} ${match[2]}`);
+        }
+    }
+    return [...titles.values()];
+}

package/cli/dist/status.d.ts

@@ -0,0 +1,3 @@
+import { type RunOptions } from "./check.ts";
+export declare function canonVersion(canonRoot: string): string;
+export declare function buildStatus(repo: string, options: RunOptions): string;

package/cli/dist/status.js

@@ -0,0 +1,26 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { loadConfig } from "./config/load.js";
+import { runChecks } from "./check.js";
+export function canonVersion(canonRoot) {
+    const manifest = join(canonRoot, ".claude-plugin", "plugin.json");
+    if (!existsSync(manifest))
+        return "unknown";
+    return JSON.parse(readFileSync(manifest, "utf8")).version ?? "unknown";
+}
+export function buildStatus(repo, options) {
+    const { config, sources } = loadConfig(repo, { estateRoot: options.estateRoot });
+    const report = runChecks(repo, options);
+    const errors = report.findings.filter((f) => f.level === "error").length;
+    const warnings = report.findings.length - errors;
+    const configLine = sources.length === 0
+        ? "none — inferred; run `canon init`"
+        : sources.map((source) => `${source.layer} ${source.path}`).join("\n         ");
+    return [
+        `canon ${canonVersion(options.canonRoot)}  ·  ${report.name}`,
+        `kind     ${config.kind}`,
+        `modules  ${config.modules.join(", ")}`,
+        `config   ${configLine}`,
+        `checks   ${errors} error${errors === 1 ? "" : "s"}, ${warnings} warning${warnings === 1 ? "" : "s"}`,
+    ].join("\n");
+}

package/cli/dist/sync.d.ts

@@ -0,0 +1,19 @@
+import { type CommandRunner } from "./packs.ts";
+export interface SyncOptions {
+    canonRoot: string;
+    estateRoot?: string;
+    cacheDir: string;
+    run: CommandRunner;
+    fetchText: (url: string) => Promise<string>;
+}
+export interface SyncResult {
+    packs: string[];
+    /** True when the managed architecture base was rewritten from canon's template. */
+    base: boolean;
+    version: {
+        from: string | undefined;
+        to: string;
+    } | null;
+}
+/** Refreshes a product's pack docs and search index, and moves its pinned canon version to the current one. */
+export declare function syncRepo(repo: string, options: SyncOptions): Promise<SyncResult>;

package/cli/dist/sync.js

@@ -0,0 +1,30 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, join } from "node:path";
+import { parseDocument } from "yaml";
+import { loadConfig } from "./config/load.js";
+import { indexKnowledge, refreshArchitectureBase } from "./init.js";
+import { fetchPackDocs, findPack } from "./packs.js";
+import { canonVersion } from "./status.js";
+/** Refreshes a product's pack docs and search index, and moves its pinned canon version to the current one. */
+export async function syncRepo(repo, options) {
+    const file = join(repo, ".claude", "canon.yaml");
+    if (!existsSync(file))
+        throw new Error(`${repo} has no .claude/canon.yaml — run \`canon init\` first`);
+    const { config } = loadConfig(repo, { estateRoot: options.estateRoot });
+    const packs = config.packs;
+    for (const name of packs) {
+        await fetchPackDocs(findPack(options.canonRoot, name), options);
+    }
+    if (config.modules.includes("knowledge"))
+        indexKnowledge(repo, basename(repo), options.run);
+    options.run("qmd", ["update"]);
+    options.run("qmd", ["embed"]);
+    const base = refreshArchitectureBase(repo, options.canonRoot);
+    const current = canonVersion(options.canonRoot);
+    if (config.canon === current)
+        return { packs, base, version: null };
+    const document = parseDocument(readFileSync(file, "utf8"));
+    document.set("canon", current);
+    writeFileSync(file, document.toString());
+    return { packs, base, version: { from: config.canon, to: current } };
+}

package/cli/dist/ui.d.ts

@@ -0,0 +1,15 @@
+export interface SiteOptions {
+    /** Quartz content folder: one symlink per product wiki, plus the home page. */
+    siteDir: string;
+    /** Static folder for the design galleries: one symlink per product designs/. */
+    designsDir: string;
+    designsUrl: string;
+    /** `canon check --all` output, shown as its own page. */
+    report: string;
+    /** A product's architecture as markdown with mermaid graphs, or undefined when it has none. */
+    graph?: (repo: string) => string | undefined;
+}
+/** Lays out the content Quartz renders and the folder the design server serves. */
+export declare function buildSite(products: string[], options: SiteOptions): void;
+/** Quartz's default config, adjusted for a private local site: no analytics, no schema files as pages. */
+export declare function quartzConfig(defaultsYaml: string): string;

package/cli/dist/ui.js

@@ -0,0 +1,69 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { basename, join } from "node:path";
+import { parseDocument } from "yaml";
+const SURFACES = ["mobile", "web"];
+function relink(target, link) {
+    rmSync(link, { force: true, recursive: false });
+    symlinkSync(target, link);
+}
+// routes.js comes in two styles (`architecture: "…"` and `"architecture": "…"`);
+// a regex reads both without executing the manifest.
+const ARCHITECTURE_KEY = /["']?architecture["']?\s*:\s*["']([^"']+)["']/;
+/** The views a drawn surface offers — flow chart, screenshots, architecture — as relative paths that exist. */
+function surfaceViews(designs, surface) {
+    const dir = join(designs, surface);
+    if (!existsSync(join(dir, "index.html")))
+        return [];
+    const views = [["flow chart", "index.html"]];
+    if (existsSync(join(dir, "screenshots.html")))
+        views.push(["screenshots", "screenshots.html"]);
+    const routes = join(dir, "routes.js");
+    const architecture = existsSync(routes) ? ARCHITECTURE_KEY.exec(readFileSync(routes, "utf8"))?.[1] : undefined;
+    if (architecture && existsSync(join(dir, architecture)))
+        views.push(["architecture", architecture]);
+    return views.map(([label, path]) => [label, `${surface}/${path}`]);
+}
+/** Lays out the content Quartz renders and the folder the design server serves. */
+export function buildSite(products, options) {
+    mkdirSync(options.siteDir, { recursive: true });
+    mkdirSync(options.designsDir, { recursive: true });
+    const rows = [];
+    for (const product of products) {
+        const name = basename(product);
+        const wiki = join(product, ".context", "wiki");
+        const designs = join(product, ".context", "designs");
+        const links = [];
+        if (existsSync(wiki)) {
+            relink(wiki, join(options.siteDir, name));
+            links.push(`[[${name}/index|${name}]]`);
+        }
+        const graph = options.graph?.(product);
+        if (graph) {
+            mkdirSync(join(options.siteDir, "architecture"), { recursive: true });
+            writeFileSync(join(options.siteDir, "architecture", `${name}.md`), `---\ntitle: ${name} architecture\n---\n\nImports between parts of ${name}, from its \`.dependency-cruiser.cjs\`. Broken rules fail \`canon check\`.\n\n${graph}\n`);
+            links.push(`[[architecture/${name}|architecture graph]]`);
+        }
+        const surfaces = SURFACES.map((surface) => [surface, surfaceViews(designs, surface)]).filter(([, views]) => views.length > 0);
+        if (surfaces.length > 0)
+            relink(designs, join(options.designsDir, name));
+        if (links.length > 0 || surfaces.length > 0)
+            rows.push(`- ${links.join(" · ") || name}`);
+        for (const [surface, views] of surfaces) {
+            const linked = views.map(([label, path]) => `[${label}](${options.designsUrl}/${name}/${path})`);
+            rows.push(`  - ${surface}: ${linked.join(" · ")}`);
+        }
+    }
+    writeFileSync(join(options.siteDir, "index.md"), `---\ntitle: canon\n---\n\nEvery product's wiki, searchable and linked. Each surface opens its flow chart, screenshots and architecture overview; products with architecture rules also get an import graph.\n\n${rows.join("\n")}\n\n[[canon-check|Standards check]]\n`);
+    writeFileSync(join(options.siteDir, "canon-check.md"), `---\ntitle: Standards check\n---\n\nOutput of \`canon check --all\` when this site was built.\n\n\`\`\`\n${options.report}\n\`\`\`\n`);
+}
+const IGNORED = ["**/CLAUDE.md", "_designs"];
+/** Quartz's default config, adjusted for a private local site: no analytics, no schema files as pages. */
+export function quartzConfig(defaultsYaml) {
+    const document = parseDocument(defaultsYaml);
+    document.setIn(["configuration", "pageTitle"], "canon");
+    document.setIn(["configuration", "analytics"], null);
+    document.setIn(["configuration", "baseUrl"], "localhost");
+    const current = document.getIn(["configuration", "ignorePatterns"])?.toJSON() ?? [];
+    document.setIn(["configuration", "ignorePatterns"], [...current, ...IGNORED.filter((p) => !current.includes(p))]);
+    return document.toString();
+}

package/package.json

@@ -1,6 +1,56 @@
 {
   "name": "@freetesh/canon",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.16.0",
+  "description": "canon CLI: keep your domain knowledge and AI rules in your repo, and enforce them.",
+  "license": "MIT",
+  "author": "Ritesh Firodiya",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ritesh-firodiya/canon-cli.git"
+  },
+  "type": "module",
+  "exports": {
+    "./api": "./cli/dist/api.js"
+  },
+  "bin": {
+    "canon": "cli/dist/index.js"
+  },
+  "files": [
+    "cli/dist",
+    "standards",
+    "skills",
+    "packs",
+    "templates",
+    "scripts/log-verdict.mjs",
+    ".claude-plugin"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "packageManager": "pnpm@12.3.4",
+  "scripts": {
+    "canon": "node cli/src/index.ts",
+    "check": "node cli/src/index.ts check . && pnpm typecheck && pnpm test",
+    "build": "rm -rf cli/dist && tsc -p cli/tsconfig.build.json",
+    "test": "vitest run --root cli",
+    "coverage": "vitest run --root cli --coverage",
+    "typecheck": "tsc -p cli",
+    "prepack": "pnpm build"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.8.1",
+    "commander": "^15.0.0",
+    "yaml": "^2.9.1",
+    "zod": "^4.6.7"
+  },
+  "devDependencies": {
+    "@types/node": "^26.6.5",
+    "@vitest/coverage-v8": "^5.0.5",
+    "dependency-cruiser": "18.7.0",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.5"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/packs/expo/pack.yaml

@@ -0,0 +1,5 @@
+name: expo
+description: Expo / React Native — versioned SDK docs
+kinds: [mobile]
+docs:
+  - https://docs.expo.dev/llms.txt

package/packs/firebase/pack.yaml

@@ -0,0 +1,5 @@
+name: firebase
+description: Firebase — auth, Firestore, rules, functions
+kinds: [mobile, web]
+docs:
+  - https://firebase.google.com/docs/llms.txt

package/packs/nextjs/pack.yaml

@@ -0,0 +1,5 @@
+name: nextjs
+description: Next.js — app router, server components, routing
+kinds: [web]
+docs:
+  - https://nextjs.org/docs/llms.txt

package/packs/react/pack.yaml

@@ -0,0 +1,5 @@
+name: react
+description: React — components, hooks, rendering
+kinds: [mobile, web]
+docs:
+  - https://react.dev/llms.txt

package/packs/revenuecat/pack.yaml

@@ -0,0 +1,5 @@
+name: revenuecat
+description: RevenueCat — subscriptions, paywalls, entitlements
+kinds: [mobile, web]
+docs:
+  - https://www.revenuecat.com/docs/llms.txt

package/packs/uniwind/pack.yaml

@@ -0,0 +1,5 @@
+name: uniwind
+description: UniWind — Tailwind classes for React Native
+kinds: [mobile]
+docs:
+  - https://docs.uniwind.dev/llms.txt

package/scripts/log-verdict.mjs

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+// Appends one verdict, and what happened next, to .context/raw/canon/verdicts.jsonl
+// in the current repo. Append-only: raw/ is immutable, and `canon learn` reads
+// the history to show how often the gate stops work and to propose rule
+// changes from overrides, so earlier lines must never be rewritten.
+import { appendFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { parseArgs } from "node:util";
+
+const VERDICTS = ["do-it", "do-it-differently", "push-back"];
+const OUTCOMES = ["proceeded", "stopped", "overridden", "dropped"];
+const PRINCIPLE_ID = /^C-\d{2}$/;
+
+const { values } = parseArgs({
+  options: {
+    verdict: { type: "string" },
+    principles: { type: "string", default: "" },
+    request: { type: "string" },
+    reason: { type: "string", default: "" },
+    outcome: { type: "string", default: "overridden" },
+    // One per term the user agreed to, verbatim. Repeat the flag for each.
+    term: { type: "string", multiple: true, default: [] },
+    repo: { type: "string", default: process.cwd() },
+  },
+});
+
+function fail(message) {
+  console.error(`log-verdict: ${message}`);
+  process.exit(1);
+}
+
+if (!VERDICTS.includes(values.verdict)) fail(`--verdict must be one of ${VERDICTS.join(", ")}`);
+if (!values.request?.trim()) fail("--request is required");
+if (!OUTCOMES.includes(values.outcome)) fail(`--outcome must be one of ${OUTCOMES.join(", ")}`);
+if (values.outcome === "overridden" && !values.reason.trim()) fail("--reason is required: an override without a reason teaches nothing");
+
+const principles = values.principles.split(",").map((id) => id.trim()).filter(Boolean);
+const invalid = principles.filter((id) => !PRINCIPLE_ID.test(id));
+if (invalid.length > 0) fail(`not principle IDs: ${invalid.join(", ")}`);
+
+const terms = values.term.map((term) => term.trim()).filter(Boolean);
+
+const entry = {
+  at: new Date().toISOString(),
+  verdict: values.verdict,
+  principles,
+  request: values.request.trim(),
+  reason: values.reason.trim(),
+  outcome: values.outcome,
+  ...(terms.length > 0 && { terms }),
+};
+
+const dir = join(values.repo, ".context", "raw", "canon");
+mkdirSync(dir, { recursive: true });
+appendFileSync(join(dir, "verdicts.jsonl"), `${JSON.stringify(entry)}\n`);
+console.log(`logged to ${join(dir, "verdicts.jsonl")}`);

package/skills/ask/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: ask
+description: Answer a question from the wiki only. Searches .context/wiki/ pages and returns a cited answer with [[wikilinks]] to every page used. Never reads .context/raw/ directly — synthesis must be written down. Usage `/ask <question>`.
+---
+
+You are answering a question using ONLY `.context/wiki/` as the knowledge source.
+
+Question: `$ARGUMENTS`
+
+## Steps
+
+1. **Search first.** If the `qmd` MCP tool is available, run a `query` for the question against this product's wiki collection (`<product>-wiki`). Its hits are the first candidates.
+
+2. **Read `.context/wiki/index.md`** and **identify candidate pages** by matching the question against page titles, IDs, and the index entries. Prefer:
+   - `entity` pages for "what is the value / price / name of X"
+   - `synthesis` pages for cross-cutting summaries (use these before chasing individual entities)
+   - `concept` pages for "why" or "what does X mean" questions
+   - `decision` pages for "why did we choose X over Y", and its `Rejected:` line for "did we consider Y"
+   - for "what does this screen do", the HTML in `.context/designs/` is the spec; its `surfaces/` note, if any, says why
+
+3. **Read the candidate pages.** Follow `[[wikilinks]]` one hop if the answer is incomplete. Stop at two hops — if you need three, the wiki is missing a synthesis page; say so.
+
+4. **Answer the question** in the product's own voice:
+   - Follow the copy rules in the root `CLAUDE.md` — plain words, short sentences, active voice.
+   - Write numbers, prices and dates the way the product writes them to a user.
+   - Cite every claim with a `[[wikilink]]` to the source page.
+   - If two pages disagree, surface the contradiction explicitly — don't pick a winner. `/wiki-lint` will flag it; the user resolves it via `/decision`.
+
+5. **If the wiki cannot answer:**
+   - Say so plainly.
+   - List the pages you checked.
+   - Suggest what's missing: "no entity page exists for `<thing>`", "no synthesis page combines `<X>` and `<Y>`", etc.
+   - Recommend the user run `/ingest <raw-source>` to fill the gap.
+
+## Rules
+
+- **Never read `.context/raw/` from this skill.** If the answer requires raw inspection, recommend `/ingest`. Designs may be read for screen questions.
+- **Never invent facts.** If a canonical value isn't in an `entity` page, say "not in the wiki".
+- **Every cited page must actually exist.** Don't fabricate a `[[wikilink]]` to make the answer look authoritative.
+- A page with `last-verified` > 90 days is stale — flag it in the answer ("last verified 2025-11-04 — may be out of date").

package/skills/decision/SKILL.md

@@ -0,0 +1,36 @@
+---
+name: decision
+description: Record or change a product or technical decision in .context/wiki/decisions/<topic>.md — one file per topic, overwritten when the choice changes. Usage `/decision <topic> — <choice and why>`.
+---
+
+You are recording a decision in `.context/wiki/decisions/<topic>.md`.
+
+Decision: `$ARGUMENTS`
+
+## Steps
+
+1. Split `$ARGUMENTS` on the first ` — `: left = topic, right = the choice and why. With no ` — `, ask for the choice.
+2. Slug = the topic in kebab-case, no date (`pricing`, `auth-provider`). Look for an existing file on the same topic first, under any name. If there is one, it is the file to change.
+3. Write the file, at most 30 lines:
+
+   ```markdown
+   ---
+   last-verified: <today>
+   ---
+   # <Topic>
+   **Choice:** <one or two lines; link values to their entity page>
+   **Why:** <the trigger: data, incident, user feedback, cost>
+   **Rejected:** <option (why)> · <option (why)>
+   ```
+
+   When changing an existing decision, replace the choice and why, and move the
+   old choice into `Rejected:` with the reason it was dropped. Keep the rest of `Rejected:`.
+4. Put a price, SKU or limit on its entity page, not here (`canonical-values` checks this).
+5. Add or update the one line in `.context/wiki/index.md`.
+6. Confirm: `decision recorded: <topic> → <path>`.
+
+## Rules
+
+- One file per topic, overwritten. Git keeps the old text; never add a dated or `-2` file.
+- No fix lists, audit results or step-by-step history. Those go in the commit message or `CHANGELOG.md`.
+- If the user's text is long, keep the choice, the reason and what was rejected, and drop the rest. Show what you dropped.

package/skills/ingest/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: ingest
+description: Turn a raw source (wireframe, meeting note, research doc) — or, with no argument, what this session taught — into wiki pages that pass the admission test, and update .context/wiki/index.md. Usage `/ingest [path-to-raw-file]`.
+---
+
+You are ingesting a raw source into the wiki at `.context/wiki/`.
+
+Source to ingest: `$ARGUMENTS`
+
+## Steps
+
+1. **Read the wiki schema (the `wiki-schema.md` that `canon standards` lists — a team's own replaces canon's; without the CLI, `../../standards/wiki-schema.md` relative to this skill) first.** It defines the folders, the one test for what belongs, and the caps. Every page you write must conform.
+
+2. **Read the raw source** at the path in `$ARGUMENTS`. Accepted: anything under `.context/raw/` or `.context/designs/`, and application source in this repository. Refuse paths outside the repo.
+   With no argument, the source is this session: list what it established that a later agent would get wrong without (a rule, a value, a choice and what was rejected). Search the wiki first and update a page rather than add one. Show the proposed changes and stop; write only when the user says so.
+
+3. **Classify** the source into one or more wiki page types:
+   - HTML wireframe → nothing; the HTML is the spec. Only a constraint it can't show becomes that screen's `surfaces/<slug>.md` note.
+   - Decision note → the `decisions/<topic>.md` file, via the `decision` skill's format
+   - Research doc / interview → typically `concept` pages (split if it covers multiple ideas), or one `synthesis` page for a brief that draws a conclusion
+   - A new tier / product / canonical value → `entity` page
+   - A user journey description → a concept, only if it holds a rule the designs don't show
+   - Write nothing an agent could read from the code, the designs or git.
+   - Don't force one source into one page — a meeting note can produce multiple pages.
+   - Folders are the four in the schema plus any listed under `wiki.types` in the repo's or the estate's `.claude/canon.yaml`, each with its folder and its required `sections` (use its `sections` headings). Use an added type only when the source fits it.
+
+4. **For each page you will create:**
+   - Filename: the topic, lowercase kebab-case, no date.
+   - Check whether a page on the topic already exists. If yes, edit it in place and refresh `last-verified` to today. Keep any `id`.
+   - Write only sections with something to say. No placeholders. Stay under the caps (page 60 lines).
+   - Link related pages with `[[slug]]` where it helps a reader. List the source path under `Sources`.
+
+5. **Update `.context/wiki/index.md`:** one line for the new page, under its folder heading, alphabetical. Don't reformat existing entries.
+
+6. **Leave the source where it is.** `.context/raw/` is immutable: a source is "processed" when a wiki page lists it under `Sources`, not when it moves.
+
+7. **Report**: list each page created or updated with its ID and path. Flag any `[[wikilinks]]` to non-existent pages as "TODO targets".
+
+## Rules
+
+- Never edit anything under `.context/raw/` or `.context/designs/`.
+- Never delete or rename an existing wiki page from this skill.
+- Never invent canonical values. If the source has a price/string/enum, copy it verbatim; if it's ambiguous, ask the user before writing.
+- Follow the copy rules from the root `CLAUDE.md` for any user-facing strings you transcribe.
+- Today's date is in the session context — use it for `last-verified`.

package/skills/standards/SKILL.md

@@ -0,0 +1,16 @@
+---
+name: standards
+description: Load the standards that cover the work before doing it — the repo's design rules, code standards, .context layout, wiki schema, agent contract, and any team-specific rules. Use before creating or changing designs, code, .context/ files, wiki pages, store listings, or anything a team rule might govern, and when asked "what are the rules for…".
+---
+
+# Load the standards that apply
+
+1. List them: run `canon standards` in the repo. It prints every standard that
+   applies — canon's defaults, then the team's and the repo's own (a team file
+   with the same name replaces canon's). If the `canon` CLI is not installed, use
+   the files in `../../standards/` (relative to this skill).
+2. Read only the ones that cover this work: designs, code, `.context/`, wiki,
+   listing, secrets — judge from the file names, then their first lines.
+3. Follow them. Where two disagree, the more specific one (the repo's, then the
+   team's, then canon's) wins; say which one you followed.
+4. Before calling the work done, run `canon check` and report its result.