@freetesh/canon 0.17.0 → 0.18.1

package/cli/dist/config/load.js

@@ -15,19 +15,6 @@ function readLayer(path) {
     }
     return parsed.data;
 }
-/** The nearest folder at or above `start` whose canon.yaml says `estate: true`, or null. */
-export function findEstate(start) {
-    let folder = resolve(start);
-    while (true) {
-        const path = configPath(folder);
-        if (existsSync(path) && readLayer(path).estate === true)
-            return folder;
-        const parent = dirname(folder);
-        if (parent === folder)
-            return null;
-        folder = parent;
-    }
-}
 /** The repo root plus each app in a monorepo's apps/ folder. */
 function appRoots(repo) {
     const apps = join(repo, "apps");
@@ -58,10 +45,19 @@ export function inferKind(repo) {
     return isPackage(repo) ? "package" : "content";
 }
 export function inferModules(repo, kind) {
-    const modules = MODULES_BY_KIND[kind];
+    return withDesign(repo, MODULES_BY_KIND[kind]);
+}
+/** A repo that draws its screens always gets the design checks, even when its modules list leaves them out. */
+function withDesign(repo, modules) {
     const hasDesigns = existsSync(join(repo, ".context", "designs"));
     return hasDesigns && !modules.includes("design") ? [...modules, "design"] : modules;
 }
+/** The sets a source repo offers under its own copies.sets; none when the source is not checked out. */
+function sourceSets(source, repo) {
+    if (!source || resolve(source) === resolve(repo) || !existsSync(configPath(source)))
+        return {};
+    return readLayer(configPath(source)).copies?.sets ?? {};
+}
 function lastDefined(values) {
     return values.filter((value) => value !== undefined).pop();
 }
@@ -72,15 +68,13 @@ function mergeBy(lists, key) {
     return [...merged.values()];
 }
 /**
- * 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 function loadConfig(repo, options = {}) {
-    const estateRoot = options.estateRoot === undefined ? findEstate(dirname(resolve(repo))) : options.estateRoot;
+export function loadConfig(repo) {
     const candidates = [
-        ...(estateRoot && resolve(estateRoot) !== resolve(repo) ? [{ layer: "estate", path: configPath(estateRoot) }] : []),
         { layer: "product", path: configPath(repo) },
         { layer: "local", path: join(repo, ".claude", "canon.local.yaml") },
     ];
@@ -88,10 +82,11 @@ export function loadConfig(repo, options = {}) {
     const layers = sources.map((source) => ({ data: readLayer(source.path), base: dirname(dirname(source.path)) }));
     const pick = (key) => layers.map((layer) => layer.data[key]);
     const kind = lastDefined(pick("kind")) ?? inferKind(repo);
+    const source = lastDefined(layers.map((layer) => (layer.data.copies?.source ? resolve(layer.base, layer.data.copies.source) : undefined)));
     const config = {
         canon: lastDefined(pick("canon")),
         kind,
-        modules: lastDefined(pick("modules")) ?? inferModules(repo, kind),
+        modules: withDesign(repo, lastDefined(pick("modules")) ?? MODULES_BY_KIND[kind]),
         expo: Object.assign({}, ...pick("expo")),
         packs: [...new Set(pick("packs").flatMap((packs) => packs ?? []))].sort(),
         standards: [...new Set(layers.flatMap((layer) => (layer.data.standards ?? []).map((entry) => (isStandardName(entry) ? entry : resolve(layer.base, entry)))))],
@@ -102,9 +97,10 @@ export function loadConfig(repo, options = {}) {
         context: { folders: mergeBy(pick("context").map((context) => context?.folders ?? []), (entry) => entry.folder) },
         pipeline: lastDefined(pick("pipeline")) ?? [],
         name: lastDefined(pick("name")),
+        formerly: [...new Set(pick("formerly").flatMap((names) => names ?? []))],
         copies: {
-            source: lastDefined(layers.map((layer) => (layer.data.copies?.source ? resolve(layer.base, layer.data.copies.source) : undefined))),
-            sets: Object.assign({}, ...pick("copies").map((copies) => copies?.sets)),
+            source,
+            sets: Object.assign({}, sourceSets(source, repo), ...pick("copies").map((copies) => copies?.sets)),
             use: [...new Set(pick("copies").flatMap((copies) => copies?.use ?? []))],
         },
     };

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

@@ -66,7 +66,6 @@ declare const tool: z.ZodObject<{
 }, z.core.$strict>;
 /** One layer of `.claude/canon.yaml` as written: every field optional. */
 export declare const layerSchema: z.ZodObject<{
-    estate: z.ZodOptional<z.ZodBoolean>;
     canon: z.ZodOptional<z.ZodString>;
     kind: z.ZodOptional<z.ZodEnum<{
         content: "content";
@@ -142,6 +141,7 @@ export declare const layerSchema: z.ZodObject<{
         gate: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strict>>>;
     name: z.ZodOptional<z.ZodString>;
+    formerly: z.ZodOptional<z.ZodArray<z.ZodString>>;
     copies: z.ZodOptional<z.ZodObject<{
         source: z.ZodOptional<z.ZodString>;
         sets: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
@@ -169,7 +169,7 @@ export interface Config {
         sdk?: number;
     };
     packs: string[];
-    /** Library standard names and absolute folders, estate first; a later file of the same name wins. */
+    /** Library standard names and absolute folders; a later file of the same name wins. */
     standards: string[];
     commands: CommandSpec[];
     doctor: {
@@ -189,6 +189,8 @@ export interface Config {
     /** Ordered stages; empty when no layer declares one. */
     pipeline: StageSpec[];
     name?: string;
+    /** Older folder names of the repo. */
+    formerly: string[];
     /** `source` is absolute, resolved from the layer that set it. `use` adds up across layers. */
     copies: {
         source?: string;

package/cli/dist/config/schema.js

@@ -80,8 +80,6 @@ const tool = z.object({ tool: z.string(), why: z.string(), hint: z.string() }).s
 /** One layer of `.claude/canon.yaml` as written: every field optional. */
 export const layerSchema = z
     .object({
-    /** Marks the folder holding this file as an estate: the parent of several products. */
-    estate: z.boolean(),
     canon: z.string(),
     kind: z.enum(KINDS),
     modules: z.array(z.enum(MODULES)),
@@ -98,9 +96,11 @@ export const layerSchema = z
     pipeline: z.array(stage),
     /** How the product is written in prose, for files shared with only the name changed. */
     name: z.string().min(1),
+    /** The repo's older folder names, so `canon flow` still counts conversations held under them. */
+    formerly: z.array(z.string().min(1)),
     /**
-     * Files copied from one source repo. The estate names sets of them; a product lists the sets it
-     * uses, and only those are held equal to the source.
+     * Files copied from one source repo. The source names sets of them in its own canon.yaml; a
+     * product names the source and lists the sets it uses, and only those are held equal to it.
      */
     copies: z.object({ source: z.string().min(1), sets: z.record(kebab, z.array(copyFile).min(1)), use: z.array(kebab) }).partial().strict(),
 })

package/cli/dist/doctor.js

@@ -1,8 +1,9 @@
 import { spawnSync } from "node:child_process";
-// What canon itself needs. A repo or estate adds its own under `doctor.tools`.
+// What canon itself needs. A repo adds its own under `doctor.tools`.
 const CORE_TOOLS = [
     { tool: "node", why: "runs the canon CLI and hooks", hint: "install Node 22+", minimum: [22, 0] },
     { tool: "git", why: "canon works on git repos", hint: "install git" },
+    { tool: "python3", why: "runs the design checks", hint: "brew install python" },
     { tool: "qmd", why: "knowledge search for Claude", hint: "npm i -g @tobilu/qmd (see the canon README)" },
 ];
 const VERSION = /(\d+)\.(\d+)(?:\.(\d+))?/;

package/cli/dist/index.js

@@ -15,13 +15,14 @@ import { registerStatus } from "./commands/status.js";
 import { registerSync } from "./commands/sync.js";
 import { registerUi } from "./commands/ui.js";
 import { registerWeigh } from "./commands/weigh.js";
-import { findEstate } from "./config/load.js";
+import { findWorkspace } from "./check.js";
 import { registerMcp } from "./commands/mcp.js";
 import { registerSearch } from "./commands/search.js";
+import { registerScripts } from "./commands/scripts.js";
 import { canonVersion } from "./status.js";
 const env = {
     canonRoot: resolve(import.meta.dirname, "..", ".."),
-    estateRoot: process.env.CANON_ESTATE ?? findEstate(process.cwd()),
+    workspace: process.env.CANON_WORKSPACE ?? findWorkspace(process.cwd()),
 };
 const program = new Command("canon")
     .description("Shared standards, knowledge and decision checks for every product.")
@@ -40,6 +41,7 @@ registerLearn(program, env);
 registerApprove(program);
 registerPipeline(program, env);
 registerWeigh(program);
+registerScripts(program, env);
 registerSearch(program);
 registerMcp(program);
 program.parseAsync().catch((error) => {

package/cli/dist/learn.d.ts

@@ -40,5 +40,5 @@ export declare function proposals(all: VerdictEntry[], options: {
     threshold: number;
     decisions: Decision[];
 }): Proposal[];
-export declare function readDecisions(estateRoot: string): Decision[];
-export declare function recordDecision(estateRoot: string, decision: Omit<Decision, "at">): void;
+export declare function readDecisions(home: string): Decision[];
+export declare function recordDecision(home: string, decision: Omit<Decision, "at">): void;

package/cli/dist/learn.js

@@ -68,13 +68,13 @@ export function proposals(all, options) {
     const decidedAt = new Map(options.decisions.map((d) => [d.id, d.count]));
     return found.filter((p) => !decidedAt.has(p.id) || p.count > (decidedAt.get(p.id) ?? 0));
 }
-// In the estate, not the canon install: a global npm install may be read-only and is replaced on upgrade.
+// Under <home>/.claude/canon, not the canon install: a global npm install may be read-only and is replaced on upgrade.
 const DECISIONS_DIR = join(".claude", "canon");
 const DECISIONS = join(DECISIONS_DIR, "decisions.jsonl");
-export function readDecisions(estateRoot) {
-    return readJsonLines(join(estateRoot, DECISIONS));
+export function readDecisions(home) {
+    return readJsonLines(join(home, DECISIONS));
 }
-export function recordDecision(estateRoot, decision) {
-    mkdirSync(join(estateRoot, DECISIONS_DIR), { recursive: true });
-    appendFileSync(join(estateRoot, DECISIONS), `${JSON.stringify({ ...decision, at: new Date().toISOString() })}\n`);
+export function recordDecision(home, decision) {
+    mkdirSync(join(home, DECISIONS_DIR), { recursive: true });
+    appendFileSync(join(home, DECISIONS), `${JSON.stringify({ ...decision, at: new Date().toISOString() })}\n`);
 }

package/cli/dist/lib/env.d.ts

@@ -1,7 +1,7 @@
 export interface Env {
     canonRoot: string;
-    /** The estate folder (parent of several products), or null when there is none. */
-    estateRoot: string | null;
+    /** The folder holding the product repos, or null when there is none. */
+    workspace: string | null;
 }
 /** For commands that only make sense across products. */
-export declare function requireEstate(env: Env): string;
+export declare function requireWorkspace(env: Env): string;

package/cli/dist/lib/env.js

@@ -1,6 +1,6 @@
 /** For commands that only make sense across products. */
-export function requireEstate(env) {
-    if (env.estateRoot)
-        return env.estateRoot;
-    throw new Error("no estate found — put `estate: true` in .claude/canon.yaml of the folder that holds your products, or set CANON_ESTATE");
+export function requireWorkspace(env) {
+    if (env.workspace)
+        return env.workspace;
+    throw new Error("no products found — run this in a product repo or the folder that holds them, or set CANON_WORKSPACE");
 }

package/cli/dist/packs.d.ts

@@ -22,10 +22,8 @@ export declare function listPacks(canonRoot: string): Pack[];
 export declare function findPack(canonRoot: string, name: string): Pack;
 interface AddOptions {
     canonRoot: string;
-    global?: boolean;
-    estateRoot?: string;
 }
-/** Records a pack in canon.yaml (product, or estate with --global), keeping the file's comments and other keys. */
+/** Records a pack in the repo's canon.yaml, keeping the file's comments and other keys. */
 export declare function addPack(repo: string, name: string, options: AddOptions): {
     file: string;
     added: boolean;

package/cli/dist/packs.js

@@ -33,16 +33,13 @@ export function findPack(canonRoot, name) {
         throw new Error(`no pack "${name}" — available: ${packs.map((p) => p.name).join(", ")}`);
     return pack;
 }
-/** Records a pack in canon.yaml (product, or estate with --global), keeping the file's comments and other keys. */
+/** Records a pack in the repo's canon.yaml, keeping the file's comments and other keys. */
 export function addPack(repo, name, options) {
     findPack(options.canonRoot, name);
-    if (options.global && !options.estateRoot)
-        throw new Error("--global needs an estate (a folder whose canon.yaml says estate: true)");
-    const base = options.global ? options.estateRoot : repo;
-    const file = join(base, ".claude", "canon.yaml");
-    if (!existsSync(file) && !options.global)
+    const file = join(repo, ".claude", "canon.yaml");
+    if (!existsSync(file))
         throw new Error(`${repo} has no .claude/canon.yaml — run \`canon init\` first`);
-    const document = parseDocument(existsSync(file) ? readFileSync(file, "utf8") : "");
+    const document = parseDocument(readFileSync(file, "utf8"));
     const current = document.get("packs")?.toJSON() ?? [];
     if (current.includes(name))
         return { file, added: false };

package/cli/dist/status.js

@@ -9,7 +9,7 @@ export function canonVersion(canonRoot) {
     return JSON.parse(readFileSync(manifest, "utf8")).version ?? "unknown";
 }
 export function buildStatus(repo, options) {
-    const { config, sources } = loadConfig(repo, { estateRoot: options.estateRoot });
+    const { config, sources } = loadConfig(repo);
     const report = runChecks(repo, options);
     const errors = report.findings.filter((f) => f.level === "error").length;
     const warnings = report.findings.length - errors;

package/cli/dist/sync.d.ts

@@ -1,7 +1,6 @@
 import { type CommandRunner } from "./packs.ts";
 export interface SyncOptions {
     canonRoot: string;
-    estateRoot?: string;
     cacheDir: string;
     run: CommandRunner;
     fetchText: (url: string) => Promise<string>;

package/cli/dist/sync.js

@@ -10,7 +10,7 @@ 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 { config } = loadConfig(repo);
     const packs = config.packs;
     for (const name of packs) {
         await fetchPackDocs(findPack(options.canonRoot, name), options);

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@freetesh/canon",
-  "version": "0.17.0",
+  "version": "0.18.1",
   "description": "canon CLI: keep your domain knowledge and AI rules in your repo, and enforce them.",
   "license": "MIT",
   "author": "Ritesh Firodiya",
+  "homepage": "https://ritesh-firodiya.github.io/products/canon/",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ritesh-firodiya/canon-cli.git"
@@ -23,6 +24,8 @@
     "templates",
     "scripts/log-verdict.mjs",
     "scripts/check-designs.py",
+    "scripts/flow.py",
+    "scripts/arch-set.py",
     ".claude-plugin"
   ],
   "engines": {

package/scripts/arch-set.py

@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+"""Gives a design set its architecture screens, the same in every product.
+
+  canon arch-set <spec.json>
+
+The spec names the set and says what to draw:
+  {
+    "set": "/abs/path/<product>/.context/designs/<surface>",
+    "lead": "One or two sentences: how the product is built.",
+    "diagrams": [["who-uses", "users", "Who uses it"], ...],    # slug, lucide icon, title
+    "stack": [{"title": "App · src/", "icon": "smartphone", "rows": [["Expo", "57", "what it is for"], ...]}, ...],
+    "own": "One sentence: the product's own code.",
+    "cost": {"title": "Cost a month", "rows": [["RevenueCat", "purchases", "$0"], ...], "total": "$0", "note": "one sentence"}
+  }
+
+Each diagram is an asset Archify already drew: <product>/.context/designs/architecture/<slug>.json and .html.
+This writes <set>/architecture/overview.html and one screen per diagram, and declares them in routes.js:
+the `architecture` field, an `architecture` flow, and an edge from the overview to each diagram.
+A phone set draws these screens without the phone frame, full width under the bar; a wide set keeps its frame.
+"""
+import json, os, re, sys
+
+spec = json.load(open(sys.argv[1]))
+SET = spec["set"]
+ASSETS = os.path.normpath(os.path.join(SET, "..", "architecture"))
+os.chdir(SET)
+
+R = open("routes.js").read()
+JSON_STYLE = '"product":' in R      # a manifest written with quoted keys
+product = re.search(r'"?product"?:\s*"([^"]+)"', R).group(1)
+fw = int(re.search(r'"?frame"?:\s*\{\s*"?w"?:\s*(\d+)', R).group(1))
+WIDE = fw >= 800
+BOX = "rounded-xl border border-line bg-surface"
+
+
+def page(file, title, body):
+    if WIDE:
+        wrap_open = '<div class="stage">\n  <div class="phone">\n    <div class="screen h-frame bg-page text-ink flex flex-col">\n'
+        wrap_close = '\n    </div>\n  </div>\n</div>\n'
+    else:
+        # A phone frame is 390px: too narrow to read a diagram. Fill the window under the bar instead.
+        wrap_open = '<div class="bg-page text-ink flex flex-col" style="height:calc(100dvh - var(--chrome-h, 48px))">\n'
+        wrap_close = '\n</div>\n'
+    return ('''<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>%s — %s</title>
+  <script src="https://cdn.tailwindcss.com/3.4.17"></script>
+  <script src="../tailwind.config.js"></script>
+  <script src="https://unpkg.com/lucide@0.544.0/dist/umd/lucide.js"></script>
+  <link rel="stylesheet" href="../shared.css" />
+</head>
+<body data-chrome data-file="architecture/%s">
+
+''' % (product, title, file) + wrap_open + body + wrap_close + '''
+<script src="../routes.js"></script>
+<script src="../_chrome.js"></script>
+<script>lucide.createIcons();</script>
+</body>
+</html>
+''')
+
+
+os.makedirs("architecture", exist_ok=True)
+
+# ---- one screen per diagram: Archify's embed mode, in a frame of the diagram's own shape
+for slug, icon, title in spec["diagrams"]:
+    src = open(os.path.join(ASSETS, slug + ".html")).read()
+    w, h = map(float, re.search(r'<svg[^>]*viewBox="0 0 ([0-9.]+) ([0-9.]+)"', src).groups())
+    body = ('<div class="flex-1 min-h-0 flex justify-center bg-page"><iframe src="../../architecture/%s.html?embed=1&amp;theme=light" title="%s" '
+            'class="border-0 max-w-full" style="height:100%%;aspect-ratio:%d / %d"></iframe></div>') % (slug, title, w, h + 24)
+    open("architecture/%s.html" % slug, "w").write(page(slug + ".html", "Architecture · " + title, body))
+
+# ---- the overview: the diagrams, the stack, the cost
+cards = "".join('<a href="%s.html" class="%s px-4 h-14 flex items-center gap-3 text-sm font-medium hover:border-line-strong"><i data-lucide="%s" class="w-4 h-4 text-ink-3"></i>%s'
+                '<i data-lucide="arrow-right" class="ml-auto w-4 h-4 text-ink-4"></i></a>' % (s, BOX, i, t) for s, i, t in spec["diagrams"])
+
+
+def table(t):
+    return ('<div class="%s overflow-hidden"><div class="px-4 h-10 flex items-center gap-2 border-b border-line text-sm font-semibold"><i data-lucide="%s" class="w-4 h-4 text-ink-3"></i>%s</div>'
+            % (BOX, t["icon"], t["title"])
+            + "".join('<div class="px-4 h-9 flex items-center gap-3 border-t border-line first:border-t-0 text-sm"><span class="w-40 shrink-0 font-medium truncate">%s</span>'
+                      '<span class="w-20 shrink-0 font-mono text-xs text-ink-3">%s</span><span class="flex-1 min-w-0 truncate text-ink-3">%s</span></div>' % tuple(r) for r in t["rows"])
+            + '</div>')
+
+
+c = spec["cost"]
+cost = ("".join('<div class="px-4 h-9 flex items-center gap-3 border-t border-line first:border-t-0 text-sm"><span class="w-40 font-medium">%s</span>'
+                '<span class="flex-1 text-ink-3">%s</span><span class="num">%s</span></div>' % tuple(r) for r in c["rows"])
+        + '<div class="px-4 h-10 flex items-center border-t border-line text-sm font-semibold"><span>A month</span><span class="ml-auto num">%s</span></div>' % c["total"])
+overview = ('<div class="flex-1 min-h-0 overflow-y-auto"><main class="max-w-[1180px] mx-auto px-6 py-8">'
+            '<h1 class="text-h2 font-semibold">How %s is built</h1>' % product
+            + '<p class="mt-2 text-base text-ink-3 max-w-[760px]">%s</p>' % spec["lead"]
+            + '<div class="mt-6 grid grid-cols-3 gap-3">' + cards + '</div>'
+            + '<h2 class="mt-10 text-h3 font-semibold">Stack</h2><div class="mt-3 grid grid-cols-2 gap-3">' + "".join(table(t) for t in spec["stack"]) + '</div>'
+            + '<p class="mt-3 text-sm text-ink-3">%s</p>' % spec["own"]
+            + '<h2 class="mt-10 text-h3 font-semibold">%s</h2>' % c["title"]
+            + '<div class="mt-3 grid grid-cols-[1fr_320px] gap-3 items-start"><div class="%s overflow-hidden">%s</div>' % (BOX, cost)
+            + '<div class="%s p-4 text-sm text-ink-3">%s</div></div>' % (BOX, c["note"])
+            + '</main></div>')
+open("architecture/overview.html", "w").write(page("overview.html", "Architecture", overview))
+
+rows = [("overview", "Architecture")] + [(s, t) for s, _, t in spec["diagrams"]]
+if JSON_STYLE:
+    # ---- routes.js, JSON-style: the field, the flow, the edges
+    if '"architecture": "architecture/overview.html"' not in R:
+        R = re.sub(r'(\n(\s*)"product":\s*"[^"]+",\n)', lambda m: m.group(1) + m.group(2) + '"architecture": "architecture/overview.html",\n', R, 1)
+    R = re.sub(r',\n    \{\n      "flow": "architecture",.*?\n    \}(?=\n  \])', "", R, flags=re.S)
+    items = ",\n".join('        {\n          "file": "architecture/%s.html",\n          "route": null,\n          "screen": "%s",\n          "states": {},\n          "status": "review",\n          "notes": "architecture"\n        }' % r for r in rows)
+    block = ',\n    {\n      "flow": "architecture",\n      "screens": [\n' + items + '\n      ]\n    }'
+    m = re.search(r'\n  "flows": \[', R)
+    end = R.index("\n  ],", m.end())
+    R = R[:end] + block + R[end:]
+    R = re.sub(r'\n\s*\{ "from": "architecture/[^"]+", "to": "architecture/[^"]+"[^}]*\},', "", R)
+    edges = "".join('\n      { "from": "architecture/overview.html", "to": "architecture/%s.html", "side": true },' % s for s, _, _ in spec["diagrams"])
+    m = re.search(r'\n\s*"edges": \[', R)
+    R = R[:m.end()] + edges + R[m.end():]
+    open("routes.js", "w").write(R)
+
+else:
+    # ---- routes.js: the field, the flow, the edges
+    files = ["architecture/overview.html"] + ["architecture/%s.html" % s for s, _, _ in spec["diagrams"]]
+    if "architecture:" not in R:
+        R = re.sub(r'(\n(\s*)product:\s*"[^"]+",\n)', lambda m: m.group(1) + m.group(2) + 'architecture: "architecture/overview.html",\n', R, 1)
+    R = re.sub(r'\n    \{ flow: "architecture", screens: \[.*?\n    \]\},', "", R, flags=re.S)
+    block = ('\n    { flow: "architecture", screens: [\n' + "".join(
+        '      { file: "architecture/%s.html", route: null, screen: "%s", status: "needs review", notes: "architecture" },\n' % r for r in rows) + '    ]},')
+    m = re.search(r'\n  flows: \[', R)
+    end = R.index("\n  ],", m.end())
+    R = R[:end] + block + R[end:]
+    R = re.sub(r'\n\s*\{ from: "architecture/[^"]+", to: "architecture/[^"]+"[^}]*\},', "", R)
+    edges = "".join('\n      { from: "architecture/overview.html", to: "architecture/%s.html", side: true },' % s for s, _, _ in spec["diagrams"])
+    m = re.search(r'\n\s*edges: \[', R)
+    if m:
+        R = R[:m.end()] + edges + R[m.end():]
+    open("routes.js", "w").write(R)
+
+print("%s: %d architecture screens, %s" % (product, len(rows), "wide" if WIDE else "phone"))

package/scripts/check-designs.py

@@ -251,7 +251,7 @@ head('architecture — the overview is declared and every framed diagram has its
 arch_page = R.get('architecture')
 arch_flow = next((fl for fl in R['flows'] if fl.get('flow') == 'architecture'), None)
 if not arch_page:
-    bad('routes.js names no `architecture` page — run bin/arch-set with this set\'s spec')
+    bad('routes.js names no `architecture` page — run `canon arch-set` with this set\'s spec')
 elif arch_page not in declared_files:
     bad('`architecture: "%s"` is not a declared screen' % arch_page)
 if arch_flow is None: