@freetesh/canon 0.16.0 → 0.18.0

package/.claude-plugin/marketplace.json

@@ -7,7 +7,7 @@
     {
       "name": "canon",
       "source": "./",
-      "version": "0.16.0",
+      "version": "0.18.0",
       "description": "Keeps your domain knowledge and AI rules in your repos and enforces them, so Claude hallucinates less."
     }
   ],

package/.claude-plugin/plugin.json

@@ -1,5 +1,5 @@
 {
   "name": "canon",
-  "version": "0.16.0",
+  "version": "0.18.0",
   "description": "Keeps your domain knowledge and AI rules in your repos and enforces them, so Claude hallucinates less."
 }

package/README.md

@@ -47,9 +47,11 @@ is a separate paid product built on this CLI.
   listing tree, dead `.context/` paths, prices with no canonical home, shared
   files, the import architecture, pipeline gates, and every checker your config
   declares. `canon hooks install` makes every push run it.
-- **Standards with one home.** canon ships defaults; an estate adds or replaces
-  them from its own folder; a repo can override again. `canon standards` shows
-  what applies.
+- **Standards with one home.** canon ships defaults every repo follows, and a
+  library a repo imports by name (`standards: [design-sets, pipeline]`): design
+  sets, the build pipeline, Expo, frontend, performance, secrets, store listings.
+  A repo's own rules can sit in a folder it adds. `canon standards` shows what
+  applies.
 - **A repo names only what it uses.** Modules, packs and shared-file sets are
   opt-in; there is no skip list and no setting that turns a check off.
 
@@ -72,57 +74,61 @@ argument captures what a session taught.
 ```bash
 canon init             # write .claude/canon.yaml and the missing .context files
 canon add              # list packs; `canon add expo` adds one and indexes its docs
-canon check            # this repo against the standards (exit 1 on any error); --all for the estate
+canon check            # this repo against the standards (exit 1 on any error); --all for every repo beside it
 canon copies --sync    # repair drifted shared files from copies.source (never adds one)
 canon hooks install    # a pre-push hook that runs `canon check` (--all: every product)
 canon standards        # which standards apply here, and where each comes from
 canon sync             # refresh pack docs and the search index, move the pinned version
 canon status           # version, kind, modules, config layers, check summary
-canon doctor           # node, git, qmd — plus any tools your config lists
+canon doctor           # node, git, python3, qmd — plus any tools your config lists
 canon learn            # proposals from overridden verdicts
 canon approve <stage>  # a person records a pipeline gate approval
 canon pipeline         # the stages this repo resolves to, and where each stands
 canon weigh "<ask>"    # the decision gate from the terminal
 canon ui               # every wiki and design gallery on localhost
 canon search "<q>"     # search the knowledge index
+canon flow <product>   # how far each local Claude conversation got against the pipeline (--write: metrics/flow.json)
+canon arch-set <spec>  # give a design set its architecture screens
 canon mcp              # the search MCP server, for any MCP client
 ```
 
 ## Config
 
-`.claude/canon.yaml`, read in layers — **estate → repo → local**
-(`canon.local.yaml`, not committed). The estate is the nearest folder above a
-repo whose `canon.yaml` says `estate: true`, or `CANON_ESTATE`.
-
-```yaml
-# <estate>/.claude/canon.yaml — shared by every repo below it
-estate: true
-standards: [.canon/standards]       # estate rules; same name replaces a canon default
-commands:                           # your own checkers, run by `canon check`
-  - { id: designs, run: ./scripts/check-designs.sh, if: .context/designs, module: design }
-  - { id: designs-first, run: test -d .context/designs, kinds: [mobile, web] }   # only repos that ship screens
-copies:                             # files products copy from one source repo, in named sets
-  source: design-system
-  sets:
-    upload: [scripts/upload.mjs]
-    shell-web:
-      - { from: designs/mobile/index.html, to: designs/web/index.html, named: true }
-```
+Every repo carries its own rules in `.claude/canon.yaml`; nothing above the repo
+is read. An uncommitted `canon.local.yaml` beside it overrides it on one machine.
+Commands that span products (`--all`, `ui`, `learn`, `flow`) use the folder that
+holds the repo you are in, or `CANON_WORKSPACE`.
 
 ```yaml
 # <repo>/.claude/canon.yaml — written by `canon init`
-canon: 0.16.0
+canon: 0.18.0
 kind: mobile                        # mobile | web | mobile-and-web | package | content
+standards: [design-sets, pipeline, expo]   # canon's library standards this repo follows; ./rules adds a folder of its own
 modules: [docs, knowledge, code, listing, refs]
 packs: [expo]
 name: Acme                          # how the product is written; `named` copies swap it in
+formerly: [acme-old]                # older folder names, so `canon flow` counts their conversations
+commands:                           # your own checkers, run by `canon check`
+  - { id: lint-copy, run: ./scripts/lint-copy.sh, if: .context/designs, module: design }
+copies:                             # files copied from one source repo, kept equal to it
+  source: ../design-system
+  use: [upload, shell-web]          # sets the source names under its own copies.sets
+```
+
+```yaml
+# ../design-system/.claude/canon.yaml — the source names its sets
 copies:
-  use: [upload, shell-web]          # the sets this repo uses; only these are held to the source
+  sets:
+    upload: [scripts/upload.mjs]
+    shell-web:
+      - { from: designs/mobile/index.html, to: designs/web/index.html, named: true }
 ```
 
-Scalars: the most specific layer wins. `packs`, `standards` and `copies.use`
-add up across layers; `commands`, `doctor.tools`, `wiki.types` and
-`context.folders` merge by name.
+Built in, for every repo: a mobile or web repo keeps `.context/designs/` (designs
+first), and a repo that draws its screens always gets the design checks.
+
+Lists of names (`packs`, `standards`, `copies.use`) add up across the two files;
+`commands`, `doctor.tools`, `wiki.types` and `context.folders` merge by name.
 
 ## Layout
 
@@ -134,8 +140,8 @@ hooks/            session start: constitution titles, qmd refresh
 standards/        default standards
 packs/            vendor doc packs
 templates/        files init writes (dependency-cruiser base and starters)
-scripts/          log-verdict.mjs — the verdict log
-evals/            plugin evals and the fixture product
+scripts/          log-verdict.mjs (the verdict log), check-designs.py, flow.py, arch-set.py
+evals/            plugin evals: the fixture product, and cases over real product repos (_scaffold/product.sh)
 cli/              the canon CLI (TypeScript, vitest); `@freetesh/canon/api` for tools built on it
 ```
 
@@ -146,7 +152,7 @@ index.ts          the program: registers every command
 api.ts            what other tools import (`@freetesh/canon/api`)
 commands/         one file per command — options and output only
 checks/           one file per check, named by its id; index.ts lists them
-config/           .claude/canon.yaml: schema, layered loading, estate discovery
+config/           .claude/canon.yaml: schema and loading
 lib/              shared helpers: files, frontmatter, env, qmd, system calls
 <name>.ts         the logic the commands call: check (+ format for its output), init, packs (add), sync, …
 ```

package/cli/dist/api.d.ts

@@ -1,3 +1,2 @@
-export { findEstate } from "./config/load.ts";
-export { findProducts } from "./check.ts";
+export { findProducts, findWorkspace } from "./check.ts";
 export { qmdQuery, qmdRefresh } from "./lib/qmd.ts";

package/cli/dist/api.js

@@ -1,4 +1,3 @@
 // What other tools build on: the canon knowledge site reads repos the way `canon check --all` finds them.
-export { findEstate } from "./config/load.js";
-export { findProducts } from "./check.js";
+export { findProducts, findWorkspace } from "./check.js";
 export { qmdQuery, qmdRefresh } from "./lib/qmd.js";

package/cli/dist/check.d.ts

@@ -11,9 +11,13 @@ export interface Report {
 export interface RunOptions {
     checks?: Check[];
     canonRoot: string;
-    estateRoot?: string | null;
     today?: Date;
 }
 export declare function runChecks(repo: string, options: RunOptions): Report;
-/** Product repos in the estate: every direct child folder holding a .context/. */
-export declare function findProducts(estateRoot: string): string[];
+/** Product repos in a workspace: every direct child folder holding a .context/. */
+export declare function findProducts(workspace: string): string[];
+/**
+ * The folder holding the product repos: the parent of the git repo `start` sits in, or `start`
+ * itself outside any repo. Null when that folder holds no product.
+ */
+export declare function findWorkspace(start: string): string | null;

package/cli/dist/check.js

@@ -1,5 +1,5 @@
 import { existsSync, readdirSync } from "node:fs";
-import { basename, join } from "node:path";
+import { basename, dirname, join, resolve } from "node:path";
 import { ALL_CHECKS } from "./checks/index.js";
 import { loadConfig } from "./config/load.js";
 import { isDirectory } from "./lib/files.js";
@@ -11,7 +11,7 @@ export function runChecks(repo, options) {
     }
     let config;
     try {
-        config = loadConfig(repo, { estateRoot: options.estateRoot }).config;
+        config = loadConfig(repo).config;
     }
     catch (error) {
         report.findings.push({ check: "config", level: "error", message: error.message });
@@ -31,10 +31,21 @@ export function runChecks(repo, options) {
     }
     return report;
 }
-/** Product repos in the estate: every direct child folder holding a .context/. */
-export function findProducts(estateRoot) {
-    return readdirSync(estateRoot, { withFileTypes: true })
-        .filter((entry) => entry.isDirectory() && existsSync(join(estateRoot, entry.name, ".context")))
-        .map((entry) => join(estateRoot, entry.name))
+/** Product repos in a workspace: every direct child folder holding a .context/. */
+export function findProducts(workspace) {
+    return readdirSync(workspace, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory() && existsSync(join(workspace, entry.name, ".context")))
+        .map((entry) => join(workspace, entry.name))
         .sort();
 }
+/**
+ * The folder holding the product repos: the parent of the git repo `start` sits in, or `start`
+ * itself outside any repo. Null when that folder holds no product.
+ */
+export function findWorkspace(start) {
+    let folder = resolve(start);
+    while (!existsSync(join(folder, ".git")) && dirname(folder) !== folder)
+        folder = dirname(folder);
+    const workspace = existsSync(join(folder, ".git")) ? dirname(folder) : resolve(start);
+    return findProducts(workspace).length > 0 ? workspace : null;
+}

package/cli/dist/checks/commands.d.ts

@@ -1,6 +1,6 @@
 import type { Check } from "./types.ts";
 /**
- * Runs each checker a repo or its estate declares under `commands:` in
+ * Runs each checker a repo declares under `commands:` in
  * canon.yaml. canon does not know what they check; a non-zero exit is an error
  * reported under the command's own id.
  */

package/cli/dist/checks/commands.js

@@ -7,7 +7,7 @@ function tail(text) {
     return text.trim().split("\n").slice(-MAX_OUTPUT_LINES).join("\n");
 }
 /**
- * Runs each checker a repo or its estate declares under `commands:` in
+ * Runs each checker a repo declares under `commands:` in
  * canon.yaml. canon does not know what they check; a non-zero exit is an error
  * reported under the command's own id.
  */

package/cli/dist/checks/designs.d.ts

@@ -0,0 +1,7 @@
+import type { Check } from "./types.ts";
+/** Every drawn surface: a folder under .context/designs/ with a routes.js manifest. */
+export declare function designSurfaces(repo: string): string[];
+/** Runs canon's design-set checker (scripts/check-designs.py) once per drawn surface. */
+export declare const designs: Check;
+/** A repo with screens draws them first (pipeline stage 1): a mobile or web repo keeps .context/designs/. */
+export declare const designsFirst: Check;

package/cli/dist/checks/designs.js

@@ -0,0 +1,46 @@
+import { spawnSync } from "node:child_process";
+import { existsSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { kindCovers } from "../config/schema.js";
+const DESIGNS = ".context/designs";
+const MAX_OUTPUT_LINES = 15;
+/** Every drawn surface: a folder under .context/designs/ with a routes.js manifest. */
+export function designSurfaces(repo) {
+    const root = join(repo, DESIGNS);
+    if (!existsSync(root))
+        return [];
+    return readdirSync(root, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory() && existsSync(join(root, entry.name, "routes.js")))
+        .map((entry) => `${DESIGNS}/${entry.name}`)
+        .sort();
+}
+/** Runs canon's design-set checker (scripts/check-designs.py) once per drawn surface. */
+export const designs = {
+    id: "designs",
+    module: "design",
+    description: "every drawn surface follows the design-sets standard (scripts/check-designs.py)",
+    run({ repo, canonRoot }) {
+        const script = join(canonRoot, "scripts", "check-designs.py");
+        return designSurfaces(repo).flatMap((surface) => {
+            const result = spawnSync("python3", [script, surface], { cwd: repo, encoding: "utf8" });
+            if (result.error)
+                return [{ check: "designs", level: "error", file: surface, message: `could not run python3: ${result.error.message}` }];
+            if (result.status === 0)
+                return [];
+            const output = `${result.stdout}\n${result.stderr}`.trim().split("\n").slice(-MAX_OUTPUT_LINES).join("\n");
+            return [{ check: "designs", level: "error", file: surface, message: output }];
+        });
+    },
+};
+/** A repo with screens draws them first (pipeline stage 1): a mobile or web repo keeps .context/designs/. */
+export const designsFirst = {
+    id: "designs-first",
+    module: null,
+    description: "a mobile or web repo draws its screens in .context/designs/ before any code",
+    run({ repo, config }) {
+        const hasScreens = kindCovers(config.kind, "mobile") || kindCovers(config.kind, "web");
+        if (!hasScreens || existsSync(join(repo, DESIGNS)))
+            return [];
+        return [{ check: "designs-first", level: "error", file: DESIGNS, message: "no .context/designs yet — stage 1 (HTML designs) comes before any code" }];
+    },
+};

package/cli/dist/checks/index.js

@@ -5,6 +5,7 @@ import { contextSize } from "./context-size.js";
 import { staleCopies } from "./stale-copies.js";
 import { standardsCopies } from "./standards-copies.js";
 import { commandChecks } from "./commands.js";
+import { designs, designsFirst } from "./designs.js";
 import { features } from "./features.js";
 import { listing } from "./listing.js";
 import { metricsDefinitions } from "./metrics-definitions.js";
@@ -30,5 +31,7 @@ export const ALL_CHECKS = [
     metricsDefinitions,
     sources,
     pipeline,
+    designsFirst,
+    designs,
     commandChecks,
 ];

package/cli/dist/checks/refs.js

@@ -15,6 +15,8 @@ const BINARY = /\.(png|jpe?g|gif|webp|ico|icns|mp4|mov|pdf|zip|aab|apk|jks|keyst
 const FEATURE_FILE = /^\.context\/features\/(\d{4})-[^/]+\.md$/;
 // A pipeline stage's `done:` paths name what will exist once that stage starts.
 const STAGE_DONE = /^\s*-\s*\{[^}]*\bdone:\s*\[/;
+// A copy set's `to:` path is where the file lands in the products that copy it, not in this repo.
+const COPY_TO = /,\s*to:.*$/;
 function git(repo, args) {
     const result = spawnSync("git", ["-C", repo, ...args], { encoding: "utf8", maxBuffer: 64 * 1024 * 1024 });
     return { status: result.status ?? 1, stdout: result.stdout ?? "" };
@@ -66,10 +68,12 @@ export const refs = {
             const links = file.startsWith(".context/") && file.endsWith(".md");
             text.split("\n").forEach((line, index) => {
                 const at = `${file}:${index + 1}`;
-                const future = file === ".claude/canon.yaml" && STAGE_DONE.test(line);
-                if (!dated && !future && line.includes(".context/") && !FROM_HISTORY.test(line)) {
-                    for (const match of line.matchAll(PATH)) {
-                        let path = literalPart(match[2], line.slice(match.index + match[0].length));
+                const inConfig = file === ".claude/canon.yaml";
+                const future = inConfig && STAGE_DONE.test(line);
+                const own = inConfig ? line.replace(COPY_TO, "") : line;
+                if (!dated && !future && own.includes(".context/") && !FROM_HISTORY.test(own)) {
+                    for (const match of own.matchAll(PATH)) {
+                        let path = literalPart(match[2], own.slice(match.index + match[0].length));
                         if (path === null)
                             continue;
                         if (match[1])

package/cli/dist/commands/add.d.ts

@@ -1,3 +1,3 @@
 import type { Command } from "commander";
-import { type Env } from "../lib/env.ts";
+import type { Env } from "../lib/env.ts";
 export declare function registerAdd(program: Command, env: Env): void;

package/cli/dist/commands/add.js

@@ -1,13 +1,11 @@
 import { resolve } from "node:path";
 import { CACHE_DIR, fetchText, runCommand } from "../lib/system.js";
 import { addPack, fetchPackDocs, findPack, listPacks } from "../packs.js";
-import { requireEstate } from "../lib/env.js";
 export function registerAdd(program, env) {
     program
         .command("add")
         .description("add a knowledge pack (rules + vendor docs in search), e.g. canon add expo")
         .argument("[pack]", "pack name; omit to list packs")
-        .option("-g, --global", "add for every product (estate canon.yaml)")
         .option("--repo <repo>", "product repo", ".")
         .action(async (name, options) => {
         if (!name) {
@@ -15,8 +13,7 @@ export function registerAdd(program, env) {
                 console.log(`${pack.name.padEnd(11)} ${pack.description}`);
             return;
         }
-        const estateRoot = options.global ? requireEstate(env) : undefined;
-        const { file, added } = addPack(resolve(options.repo), name, { canonRoot: env.canonRoot, global: options.global, estateRoot });
+        const { file, added } = addPack(resolve(options.repo), name, { canonRoot: env.canonRoot });
         console.log(added ? `added ${name} to ${file}` : `${name} already in ${file}`);
         const dir = await fetchPackDocs(findPack(env.canonRoot, name), { cacheDir: CACHE_DIR, fetchText, run: runCommand });
         console.log(`indexed ${dir} as qmd://pack-${name}`);

package/cli/dist/commands/check.js

@@ -1,18 +1,18 @@
 import { resolve } from "node:path";
 import { exitCode, formatReports } from "../format.js";
 import { findProducts, runChecks } from "../check.js";
-import { requireEstate } from "../lib/env.js";
+import { requireWorkspace } from "../lib/env.js";
 export function registerCheck(program, env) {
     program
         .command("check")
         .description("check that a product follows the standards (read-only)")
         .argument("[repo]", "product repo", ".")
-        .option("--all", "check every product in the estate")
+        .option("--all", "check every product in the workspace")
         .option("--json", "print machine-readable JSON")
         .option("-q, --quiet", "hide products with no findings")
         .action((repo, options) => {
-        const repos = options.all ? findProducts(requireEstate(env)) : [resolve(repo)];
-        const reports = repos.map((path) => runChecks(path, { canonRoot: env.canonRoot, estateRoot: options.all ? env.estateRoot : undefined }));
+        const repos = options.all ? findProducts(requireWorkspace(env)) : [resolve(repo)];
+        const reports = repos.map((path) => runChecks(path, { canonRoot: env.canonRoot }));
         console.log(options.json ? JSON.stringify(reports, null, 2) : formatReports(reports, { quiet: options.quiet }));
         process.exitCode = exitCode(reports);
     });

package/cli/dist/commands/copies.js

@@ -9,7 +9,7 @@ export function registerCopies(program, env) {
         .option("--sync", "overwrite drifted copies from the source (never adds a missing file)")
         .action((repo, options) => {
         const path = resolve(repo);
-        const { config } = loadConfig(path, { estateRoot: env.estateRoot });
+        const { config } = loadConfig(path);
         if (options.sync) {
             const written = syncCopies(path, config);
             console.log(written.length ? written.map((file) => `  synced: ${file}`).join("\n") : "  nothing to sync");

package/cli/dist/commands/hooks.js

@@ -2,9 +2,9 @@ import { spawnSync } from "node:child_process";
 import { chmodSync, existsSync, lstatSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { findProducts } from "../check.js";
-import { requireEstate } from "../lib/env.js";
+import { requireWorkspace } from "../lib/env.js";
 const MARK = "installed by `canon hooks install`";
-// Hooks written by the tools this command replaced (the estate script, then zeno); they are ours to overwrite.
+// Hooks written by the tools this command replaced (the old ~/git/bin script, then zeno); they are ours to overwrite.
 const OLD_MARKS = [MARK, "installed by ~/git/bin/install-hooks", "installed by `zeno hooks install`"];
 export const HOOK = `#!/bin/sh
 # ${MARK} — run it again rather than editing this file.
@@ -44,11 +44,11 @@ export function registerHooks(program, env) {
         .description("install a pre-push hook that runs `canon check`")
         .argument("<action>", "install")
         .argument("[repo]", "product repo", ".")
-        .option("--all", "every product in the estate")
+        .option("--all", "every product in the workspace")
         .action((action, repo, options) => {
         if (action !== "install")
             throw new Error(`unknown action ${action} — use: canon hooks install`);
-        const repos = options.all ? findProducts(requireEstate(env)) : [resolve(repo)];
+        const repos = options.all ? findProducts(requireWorkspace(env)) : [resolve(repo)];
         for (const path of repos)
             console.log(`  ${installHook(path)}`);
     });

package/cli/dist/commands/learn.js

@@ -1,7 +1,10 @@
+import { homedir } from "node:os";
 import { proposals, readDecisions, readVerdicts, recordDecision, summarise } from "../learn.js";
 import { findProducts } from "../check.js";
-import { requireEstate } from "../lib/env.js";
+import { requireWorkspace } from "../lib/env.js";
 const DEFAULT_THRESHOLD = 3;
+// The decisions log lives in the user's home: it spans every product and must survive canon upgrades.
+const DECISIONS_HOME = homedir();
 export function registerLearn(program, env) {
     program
         .command("learn")
@@ -11,15 +14,14 @@ export function registerLearn(program, env) {
         .option("--reject <id>", "mark a proposal rejected; it returns only with new evidence")
         .option("--note <text>", "why, for --approve / --reject", "")
         .action((options) => {
-        const estateRoot = requireEstate(env);
-        const entries = readVerdicts(findProducts(estateRoot));
-        const found = proposals(entries, { threshold: Number(options.threshold), decisions: readDecisions(estateRoot) });
+        const entries = readVerdicts(findProducts(requireWorkspace(env)));
+        const found = proposals(entries, { threshold: Number(options.threshold), decisions: readDecisions(DECISIONS_HOME) });
         const target = options.approve ?? options.reject;
         if (target) {
             const proposal = found.find((p) => p.id === target);
             if (!proposal)
                 throw new Error(`no open proposal "${target}" — run \`canon learn\` to list them`);
-            recordDecision(estateRoot, { id: target, decision: options.approve ? "approved" : "rejected", count: proposal.count, note: options.note });
+            recordDecision(DECISIONS_HOME, { id: target, decision: options.approve ? "approved" : "rejected", count: proposal.count, note: options.note });
             console.log(`${options.approve ? "approved" : "rejected"} ${target}`);
             return;
         }

package/cli/dist/commands/pipeline.js

@@ -4,12 +4,12 @@ import { stagesOf } from "../pipeline.js";
 export function registerPipeline(program, env) {
     program
         .command("pipeline")
-        .description("the repo's stages in order — the estate's list unless the product declares its own — and where each stands")
+        .description("the repo's stages in order — and where each stands")
         .argument("[repo]", "product repo", ".")
         .option("--json", "print JSON, for scripts")
         .action((repo, options) => {
         const root = resolve(repo);
-        const stages = stagesOf(root, loadConfig(root, { estateRoot: env.estateRoot }).config.pipeline);
+        const stages = stagesOf(root, loadConfig(root).config.pipeline);
         if (options.json) {
             console.log(JSON.stringify(stages, null, 2));
             return;

package/cli/dist/commands/scripts.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from "commander";
+import { type Env } from "../lib/env.ts";
+export declare function registerScripts(program: Command, env: Env): void;

package/cli/dist/commands/scripts.js

@@ -0,0 +1,32 @@
+import { spawnSync } from "node:child_process";
+import { join, resolve } from "node:path";
+import { findProducts } from "../check.js";
+import { loadConfig } from "../config/load.js";
+import { requireWorkspace } from "../lib/env.js";
+/** Runs one of canon's Python scripts with the terminal attached, and passes its exit code on. */
+function runScript(env, script, args, extraEnv = {}) {
+    const result = spawnSync("python3", [join(env.canonRoot, "scripts", script), ...args], { stdio: "inherit", env: { ...process.env, ...extraEnv } });
+    if (result.error)
+        throw new Error(`could not run python3: ${result.error.message}`);
+    process.exitCode = result.status ?? 1;
+}
+export function registerScripts(program, env) {
+    program
+        .command("flow")
+        .description("how far each local Claude conversation about a product got against its pipeline, and how long each step took")
+        .argument("<product...>", "product folder names in the workspace")
+        .option("--write", "also write <product>/.context/metrics/flow.json")
+        .action((products, options) => {
+        const workspace = requireWorkspace(env);
+        const formerly = Object.fromEntries(findProducts(workspace).map((repo) => [resolve(repo).split("/").pop(), loadConfig(repo).config.formerly]));
+        runScript(env, "flow.py", [...products, ...(options.write ? ["--write"] : [])], {
+            CANON_WORKSPACE: workspace,
+            CANON_FLOW_FORMERLY: JSON.stringify(formerly),
+        });
+    });
+    program
+        .command("arch-set")
+        .description("give a design set its architecture screens from a spec (see scripts/arch-set.py)")
+        .argument("<spec>", "spec.json naming the set and what to draw")
+        .action((spec) => runScript(env, "arch-set.py", [resolve(spec)]));
+}

package/cli/dist/commands/standards.js

@@ -4,7 +4,7 @@ import { constitutionTitles, resolveStandards } from "../standards.js";
 export function registerStandards(program, env) {
     program
         .command("standards")
-        .description("list the standards that apply to a repo: canon's defaults, then the estate's and the repo's")
+        .description("list the standards that apply to a repo: canon's defaults, then the ones the repo imports")
         .argument("[repo]", "product repo", ".")
         .option("--json", "print machine-readable JSON")
         .option("--constitution", "print only the principle titles, canon's then any added ones")

package/cli/dist/commands/sync.js

@@ -10,7 +10,7 @@ export function registerSync(program, env) {
         .argument("[repo]", "product repo", ".")
         .action(async (repo) => {
         const path = resolve(repo);
-        const result = await syncRepo(path, { canonRoot: env.canonRoot, estateRoot: env.estateRoot ?? undefined, cacheDir: CACHE_DIR, fetchText, run: runCommand });
+        const result = await syncRepo(path, { canonRoot: env.canonRoot, cacheDir: CACHE_DIR, fetchText, run: runCommand });
         console.log(`packs refreshed: ${result.packs.join(", ") || "none"}`);
         if (result.base)
             console.log("architecture base updated from canon's template");

package/cli/dist/commands/ui.js

@@ -6,7 +6,7 @@ import { formatReports } from "../format.js";
 import { CACHE_DIR } from "../lib/system.js";
 import { findProducts, runChecks } from "../check.js";
 import { buildSite, quartzConfig } from "../ui.js";
-import { requireEstate } from "../lib/env.js";
+import { requireWorkspace } from "../lib/env.js";
 // Quartz v5 has no tagged release yet, so pin the exact commit: an unpinned
 // clone could change the site under us on the next fresh install.
 const QUARTZ_REPO = "https://github.com/jackyzha0/quartz";
@@ -37,11 +37,11 @@ export function registerUi(program, env) {
         .option("--ws-port <port>", "live-reload socket port", "4612")
         .action((options) => {
         ensureQuartz();
-        const products = findProducts(requireEstate(env));
+        const products = findProducts(requireWorkspace(env));
         const siteDir = join(CACHE_DIR, "site");
         const designsDir = join(CACHE_DIR, "designs");
         const designsUrl = `http://127.0.0.1:${options.designsPort}`;
-        const report = formatReports(products.map((repo) => runChecks(repo, { canonRoot: env.canonRoot, estateRoot: env.estateRoot })));
+        const report = formatReports(products.map((repo) => runChecks(repo, { canonRoot: env.canonRoot })));
         buildSite(products, { siteDir, designsDir, designsUrl, report, graph: architectureGraph });
         const designs = spawn("python3", ["-m", "http.server", options.designsPort, "--bind", "127.0.0.1", "--directory", designsDir], {
             stdio: "ignore",

package/cli/dist/config/load.d.ts

@@ -1,23 +1,17 @@
 import { type Config, type Kind, type Module } from "./schema.ts";
 export interface ConfigSource {
-    layer: "estate" | "product" | "local";
+    layer: "product" | "local";
     path: string;
 }
-export interface LoadOptions {
-    /** The estate folder; found by walking up from the repo when not given. */
-    estateRoot?: string | null;
-}
-/** The nearest folder at or above `start` whose canon.yaml says `estate: true`, or null. */
-export declare function findEstate(start: string): string | null;
 export declare function inferKind(repo: string): Kind;
 export declare function inferModules(repo: string, kind: Kind): Module[];
 /**
- * Reads the estate, product and local canon.yaml layers over defaults inferred
- * from the repo. Scalars: the most specific layer wins. Lists of names add up
+ * Reads the repo's canon.yaml and its uncommitted canon.local.yaml over defaults
+ * inferred from the repo. Scalars: the local layer wins. Lists of names add up
  * (packs, standards); lists of records merge by their key (commands, tools,
- * wiki types, context folders).
+ * wiki types, context folders). Copy sets come from the source repo's canon.yaml.
  */
-export declare function loadConfig(repo: string, options?: LoadOptions): {
+export declare function loadConfig(repo: string): {
     config: Config;
     sources: ConfigSource[];
 };