naive-framework 0.0.0-stage → 0.1.0

package/schema/team-plan.schema.json

@@ -0,0 +1,157 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "team-plan.schema.json",
+  "title": "Team plan",
+  "description": "Who the venture needs, agent or person, when, with what authority, and where a human stays in the loop (EE-029), at <venture>/operations/team-plan.json. Tasks cite the agent capability register; recruiting briefs say what each open person role is for.",
+  "type": "object",
+  "required": [
+    "venture",
+    "roles"
+  ],
+  "additionalProperties": false,
+  "properties": {
+    "venture": {
+      "type": "string"
+    },
+    "updated": {
+      "type": "string",
+      "format": "date"
+    },
+    "note": {
+      "type": "string"
+    },
+    "roles": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "required": [
+          "id",
+          "occupant",
+          "needed_by",
+          "status"
+        ],
+        "additionalProperties": false,
+        "properties": {
+          "id": {
+            "type": "string",
+            "description": "A role id from the role registry, or the venture's own"
+          },
+          "name": {
+            "type": "string",
+            "description": "Required for a role not in the registry"
+          },
+          "occupant": {
+            "enum": [
+              "agent",
+              "person"
+            ]
+          },
+          "needed_by": {
+            "enum": [
+              "discovery",
+              "validation",
+              "beachhead",
+              "scale",
+              "platform"
+            ]
+          },
+          "status": {
+            "enum": [
+              "filled",
+              "open",
+              "planned"
+            ]
+          },
+          "why": {
+            "type": "string"
+          },
+          "authority": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "description": "Decision classes delegated to this role"
+          },
+          "tasks": {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "required": [
+                "capability"
+              ],
+              "additionalProperties": false,
+              "properties": {
+                "capability": {
+                  "type": "string"
+                },
+                "human_loop": {
+                  "type": "string",
+                  "description": "The person role that decides, reviews or does the part agents cannot"
+                }
+              }
+            }
+          },
+          "routes": {
+            "type": "object",
+            "additionalProperties": false,
+            "description": "The routes this role may reach (robots, EE-032), as globs over routes such as purpose/** or purpose/product/*. Left out, the role may reach every route; gates still apply. When given, read defaults to every route and write to none.",
+            "properties": {
+              "read": {
+                "type": "array",
+                "items": {
+                  "type": "string"
+                }
+              },
+              "write": {
+                "type": "array",
+                "items": {
+                  "type": "string"
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "recruiting": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": [
+          "role",
+          "brief"
+        ],
+        "additionalProperties": false,
+        "properties": {
+          "role": {
+            "type": "string"
+          },
+          "kind": {
+            "enum": [
+              "cofounder",
+              "hire",
+              "contractor",
+              "advisor",
+              "investor"
+            ]
+          },
+          "brief": {
+            "type": "string",
+            "description": "A recruiting brief, relative to the venture folder"
+          },
+          "channels": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          },
+          "assisted_by": {
+            "type": "string",
+            "description": "The agent role that drafts, searches and screens"
+          }
+        }
+      }
+    }
+  }
+}

package/schema/telos.schema.json

@@ -0,0 +1,197 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "telos.schema.json",
+  "title": "Telos",
+  "description": "The end a venture exists to reach, at <venture>/purpose/telos.json (EE-023): start with the end. It states the end state, how anyone would know it was reached (measures), what the owners intend to happen when it is reached (owner outcome), and, for each phase of the Succession Matrix, the exit criteria that must be true to leave it, each serving at least one measure. Other layers read it instead of asking again: the governance layer's exit.json prefers the owner outcome's path, and MAD's governance tier takes its success measure from the primary measure. schema/check-telos.mjs checks it. Written by the owner; an agent may draft it but not settle it.",
+  "type": "object",
+  "required": [
+    "statement",
+    "end_state",
+    "measures",
+    "owner_outcome"
+  ],
+  "additionalProperties": false,
+  "properties": {
+    "statement": {
+      "type": "string",
+      "description": "The end, in one sentence: what the venture is for when it has done its job"
+    },
+    "end_state": {
+      "type": "string",
+      "description": "What is true in the world when the end is reached"
+    },
+    "horizon": {
+      "type": [
+        "integer",
+        "string"
+      ],
+      "description": "The year the end should be reached by, or 'open'"
+    },
+    "measures": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "required": [
+          "id",
+          "statement",
+          "kind"
+        ],
+        "additionalProperties": false,
+        "properties": {
+          "id": {
+            "type": "string",
+            "pattern": "^[a-z0-9-]+$"
+          },
+          "statement": {
+            "type": "string"
+          },
+          "target": {
+            "type": "string"
+          },
+          "kind": {
+            "enum": [
+              "revenue",
+              "usage_or_adoption",
+              "cost_or_time_saved",
+              "compliance_met",
+              "learning",
+              "flow_and_lead_time",
+              "impact"
+            ],
+            "description": "The kind of measure; the first six match MAD's success_measure answers, impact is a change in the world beyond the venture"
+          },
+          "primary": {
+            "type": "boolean",
+            "description": "Exactly one measure is primary"
+          }
+        }
+      }
+    },
+    "owner_outcome": {
+      "type": "object",
+      "required": [
+        "path"
+      ],
+      "additionalProperties": false,
+      "properties": {
+        "path": {
+          "enum": [
+            "acquisition",
+            "ipo",
+            "secondary-sale",
+            "merger",
+            "management-buyout",
+            "wind-down",
+            "hold"
+          ],
+          "description": "What the owners intend to happen once the end is reached; hold means they keep it"
+        },
+        "why": {
+          "type": "string"
+        }
+      }
+    },
+    "phases": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": [
+          "phase",
+          "exit_criteria"
+        ],
+        "additionalProperties": false,
+        "properties": {
+          "phase": {
+            "enum": [
+              "discovery",
+              "validation",
+              "beachhead",
+              "scale",
+              "platform"
+            ]
+          },
+          "exit_criteria": {
+            "type": "array",
+            "minItems": 1,
+            "items": {
+              "type": "object",
+              "required": [
+                "id",
+                "statement",
+                "serves"
+              ],
+              "additionalProperties": false,
+              "properties": {
+                "id": {
+                  "type": "string",
+                  "pattern": "^[a-z0-9-]+$"
+                },
+                "statement": {
+                  "type": "string"
+                },
+                "serves": {
+                  "type": "array",
+                  "minItems": 1,
+                  "items": {
+                    "type": "string"
+                  },
+                  "description": "Measure ids this criterion moves the venture toward"
+                },
+                "evidence": {
+                  "type": "string",
+                  "description": "How it is shown: a check command, an evidence record, or a metric"
+                }
+              }
+            }
+          }
+        }
+      },
+      "description": "Per phase, what must be true to leave it; refines that phase's generic gate in purpose/frameworks/product-anatomy/phases.json for this venture"
+    },
+    "steering": {
+      "type": "object",
+      "additionalProperties": false,
+      "description": "How the venture decides to start, keep going or stop, when it reviews that, and what happens when evidence says the direction is wrong (EE-040; MAD's governance tier reads these as go_decision, review_cadence and change_of_direction). Who may make each call is in the decision rights: continue-or-stop and change-direction.",
+      "properties": {
+        "go_decision": {
+          "enum": [
+            "test-hypotheses-first",
+            "business-case-upfront",
+            "owner-judgment",
+            "last-responsible-moment",
+            "other"
+          ],
+          "description": "test-hypotheses-first: assumptions are written down and tested with real people before committing. business-case-upfront: a case is approved before work starts. owner-judgment: the owner decides as they go. last-responsible-moment: commitments wait until delay costs more than deciding."
+        },
+        "review": {
+          "enum": [
+            "per-experiment",
+            "per-release",
+            "fixed-period",
+            "continuous",
+            "none"
+          ],
+          "description": "When the decision to continue is reviewed: after each experiment or customer test, at each release or milestone, on a calendar, continuously from watched measures, or never formally"
+        },
+        "review_period": {
+          "type": "string",
+          "description": "For fixed-period: the period, such as quarterly"
+        },
+        "change_of_direction": {
+          "enum": [
+            "pivot-on-evidence",
+            "formal-change-control",
+            "owner-decides",
+            "public-proposal",
+            "other"
+          ],
+          "description": "pivot-on-evidence: changing the product, customer or model is expected and planned for. formal-change-control: a change request the deciders approve or reject. owner-decides: the owner adjusts as they see fit. public-proposal: anyone proposes in public and maintainers decide by a published rule."
+        },
+        "note": {
+          "type": "string"
+        }
+      }
+    }
+  }
+}

package/schema/time-to-ready.mjs

@@ -0,0 +1,93 @@
+// Time to running, and time to ready per layer and per MAD tier (the telos's Option B measure).
+//
+//   running: the venture is operating when its core promise is written, a product is live with at
+//     least one account, and the next phase's exit criteria exist in the telos.
+//     The date is the latest of the dates those records first appeared.
+//   layer ready: every record the need-now score suggests for the current phase exists in that
+//     layer; the date is when the last of them first appeared. A layer still missing one is not
+//     ready, and the missing records are listed.
+//   tier ready: the operations-readiness record's ready_on per MAD tier.
+// A record's date is when git first saw the file, else the file's own updated or opened date.
+//
+//   node schema/time-to-ready.mjs <venture dir> [--json]
+
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { needNow } from "./need-now.mjs";
+
+const load = (p) => JSON.parse(readFileSync(p, "utf8"));
+const day = (d) => d ? d.slice(0, 10) : null;
+const days = (a, b) => a && b ? Math.round((new Date(b) - new Date(a)) / 864e5) : null;
+
+function firstSeen(file) {
+  try {
+    const out = execFileSync("git", ["log", "--diff-filter=A", "--follow", "--format=%as", "--", file], { cwd: dirname(file), encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim().split("\n").filter(Boolean);
+    if (out.length) return out[out.length - 1];
+  } catch {}
+  try { const j = load(file); if (j.updated || j.opened) return day(j.updated ?? j.opened); } catch {}
+  return day(statSync(file).mtime.toISOString());
+}
+
+const files = (d, base = d) => existsSync(d) ? readdirSync(d, { withFileTypes: true }).flatMap((e) =>
+  e.isDirectory() ? files(join(d, e.name), base) : [join(d, e.name).slice(base.length + 1)]) : [];
+const glob = (g) => new RegExp("^" + g.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*\//g, "\0").replace(/\*/g, "[^/]*").replace(/\0/g, "(?:[^/]+/)*") + "$");
+
+export function timeToReady(dir) {
+  const repo = new URL("..", import.meta.url).pathname;
+  const model = load(join(repo, "schema/data-model.json"));
+  const v = load(join(dir, "venture.json"));
+  const start = day(v.opened) ?? firstSeen(join(dir, "venture.json"));
+  const here = files(dir);
+  const where = (type) => {
+    const rels = (model.records.find((r) => r.id === type)?.paths ?? []).filter((p) => p.startsWith("instance/**/")).map((p) => p.slice("instance/**/".length));
+    return here.filter((x) => rels.some((g) => glob(g).test(x)));
+  };
+  const seen = (type) => { const fs = where(type); return fs.length ? fs.map((f) => firstSeen(join(dir, f))).sort()[0] : null; };
+
+  // Running.
+  const nn = needNow(dir);
+  const products = where("product").map((f) => ({ f, p: load(join(dir, f)) }));
+  const offered = products.filter(({ p }) => p.status === "live");
+  const telosFile = where("telos")[0];
+  const telos = telosFile ? load(join(dir, telosFile)) : null;
+  const conditions = {
+    promise: v.core?.promise ? firstSeen(join(dir, "venture.json")) : null,
+    product_offered: offered.length ? offered.map(({ f }) => firstSeen(join(dir, f))).sort()[0] : null,
+    first_account: seen("account"),
+    next_exit_criteria: nn.next && telos?.phases?.some((p) => p.phase === nn.next) ? firstSeen(join(dir, telosFile)) : null,
+  };
+  const missing = Object.entries(conditions).filter(([, d]) => !d).map(([k]) => k);
+  const runningOn = missing.length ? null : Object.values(conditions).sort().at(-1);
+
+  // Layers.
+  const layers = {};
+  for (const row of nn.rows.filter((r) => r.status === "held" || r.status === "suggest now")) {
+    const l = row.layer ?? "system";
+    layers[l] ??= { dates: [], missing: [] };
+    const d = seen(row.type);
+    if (d) layers[l].dates.push(d); else layers[l].missing.push(row.type);
+  }
+  const layerRows = Object.entries(layers).map(([layer, x]) => {
+    const on = x.missing.length ? null : x.dates.sort().at(-1) ?? null;
+    return { layer, ready_on: on, days: days(start, on), missing: x.missing };
+  });
+
+  // MAD tiers.
+  const opsFile = where("validation-operations-readiness")[0];
+  const tiers = opsFile ? load(join(dir, opsFile)).tiers.map((t) => ({ tier: t.tier, ready_on: t.ready_on ?? null, days: days(start, t.ready_on) })) : [];
+
+  return { venture: v.id, phase: nn.phase, started: start, running: { on: runningOn, days: days(start, runningOn), missing, conditions }, layers: layerRows, tiers };
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const dir = process.argv[2];
+  if (!dir || !existsSync(join(dir, "venture.json"))) { console.error("usage: node schema/time-to-ready.mjs <venture dir> [--json]"); process.exit(2); }
+  const r = timeToReady(dir);
+  if (process.argv.includes("--json")) { console.log(JSON.stringify(r, null, 2)); process.exit(0); }
+  console.log(`${r.venture}: started ${r.started}, phase ${r.phase}`);
+  console.log(r.running.on ? `running since ${r.running.on} (${r.running.days} days to running)` : `not running yet: missing ${r.running.missing.join(", ")}`);
+  console.log("\nlayer ready (for what the current phase needs)");
+  for (const l of r.layers) console.log(`  ${l.layer.padEnd(12)} ${l.ready_on ? `${l.ready_on} (${l.days} days)` : `not ready: ${l.missing.join(", ")}`}`);
+  if (r.tiers.length) { console.log("\nMAD tier ready"); for (const t of r.tiers) console.log(`  ${t.tier.padEnd(22)} ${t.ready_on ? `${t.ready_on} (${t.days} days)` : "not ready"}`); }
+}

package/schema/upgrade-venture.mjs

@@ -0,0 +1,129 @@
+#!/usr/bin/env node
+// naive upgrade: moves one venture onto the next Naive layout, here the package folder layout
+// (EE-070), like next upgrade and its codemods (EE-076). Files move with git mv when git tracks
+// them, wherever the venture's repository is, and with a plain rename when it does not.
+// Provenance is appended, never rewritten: each move is a new line, and the set of moves
+// is one release under .release/. Old routes keep resolving through interface/route-aliases.json.
+//
+//   node schema/upgrade-venture.mjs <venture dir>
+
+import { execSync } from "node:child_process";
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { record } from "../interface/provenance.mjs";
+
+const dir = process.argv[2];
+if (!dir || !existsSync(join(dir, "venture.json"))) {
+  console.error("usage: node schema/upgrade-venture.mjs <venture dir>");
+  process.exit(2);
+}
+const load = (p) => JSON.parse(readFileSync(p, "utf8"));
+const moved = [];
+const escalated = [];
+
+function mv(fromRel, toRel) {
+  const from = join(dir, fromRel), to = join(dir, toRel);
+  if (!existsSync(from)) return;
+  if (existsSync(to)) { console.error(`${toRel} already exists`); process.exit(1); }
+  mkdirSync(dirname(to), { recursive: true });
+  try { execSync(`git mv ${JSON.stringify(from)} ${JSON.stringify(to)}`, { cwd: dir, stdio: "pipe" }); }
+  catch { renameSync(from, to); }
+  moved.push([fromRel, toRel]);
+}
+
+// A decision file infers its target from the folder it sits in. Stamp that path before the
+// file moves, so the decision still points at the same record.
+function stampDecisions(folder) {
+  const d = join(dir, folder);
+  if (!existsSync(d)) return;
+  for (const f of readdirSync(d).filter((x) => x.endsWith(".decision.json"))) {
+    const path = join(d, f);
+    const rec = load(path);
+    if (rec.decides?.path) continue;
+    const at = folder.split("/").slice(0, -1).join("/");
+    const base = f.split(".")[0];
+    rec.decides = { ...(rec.decides ?? {}), path: at ? `${at}/${base}.json` : `${base}.json` };
+    writeFileSync(path, JSON.stringify(rec, null, 2) + "\n");
+  }
+}
+
+const pairs = [
+  ["purpose/validation/problem.json", "foundation/problem.json"],
+  ["purpose/icp.json", "foundation/icp.json"],
+  ["purpose/alignment.json", "foundation/alignment.json"],
+  ["purpose/telos.draft.md", "foundation/telos.draft.md"],
+  ["purpose/validation/solution.json", "validation/solution.json"],
+  ["purpose/validation/go-to-market.json", "validation/go-to-market.json"],
+  ["operations/team-plan.json", "people/team-plan.json"],
+  ["pillars/brand.md", "marketing/brand.md"],
+  // A venture made since init writes a root AGENTS.md keeps it; the old README becomes the knowledge layout.
+  ["knowledge/README.md", existsSync(join(dir, "AGENTS.md")) ? "knowledge/AGENTS.md" : "AGENTS.md"],
+  ["purpose/anatomy.answers.reasoned.json", "product/anatomy.answers.reasoned.json"],
+  ["purpose/anatomy.matrix.md", "product/anatomy.matrix.md"],
+];
+for (const [a, b] of pairs) mv(a, b);
+
+const products = existsSync(join(dir, "products")) ? readdirSync(join(dir, "products")).filter((f) => f.endsWith(".json")) : [];
+for (const f of products) mv(`products/${f}`, `product/${f}`);
+
+const anatomy = existsSync(join(dir, "purpose/anatomy")) ? readdirSync(join(dir, "purpose/anatomy")).filter((f) => f.endsWith(".json")) : [];
+for (const f of anatomy) mv(`purpose/anatomy/${f}`, `product/anatomy/${f}`);
+
+for (const folder of ["purpose/decisions", "purpose/anatomy/decisions", "operations/decisions"]) {
+  stampDecisions(folder);
+  const d = join(dir, folder);
+  if (!existsSync(d)) continue;
+  for (const f of readdirSync(d).filter((x) => x.endsWith(".decision.json"))) mv(`${folder}/${f}`, `decisions/${f}`);
+}
+
+for (const f of ["product.md", "business.md"]) {
+  if (existsSync(join(dir, "pillars", f))) {
+    mv(`pillars/${f}`, `_private/pillars/${f}`);
+    escalated.push(`${f.replace(".md", "")} pillar: the brief names a home only for brand (marketing/). Archived at _private/pillars/${f} rather than guessed.`);
+  }
+}
+const research = join(dir, "purpose/research");
+if (existsSync(research)) {
+  for (const f of readdirSync(research)) {
+    mv(`purpose/research/${f}`, `_private/research/${f}`);
+    escalated.push(`purpose/research/${f}: no package home in the route table. Archived at _private/research/${f}.`);
+  }
+}
+
+function removeEmpty(p) {
+  if (!existsSync(p)) return;
+  for (const e of readdirSync(p, { withFileTypes: true })) if (e.isDirectory()) removeEmpty(join(p, e.name));
+  if (readdirSync(p).length === 0) rmSync(p, { recursive: true });
+}
+for (const gone of ["purpose", "pillars", "knowledge", "products"]) removeEmpty(join(dir, gone));
+
+const policy = join(dir, "governance/publication-policy.json");
+if (existsSync(policy)) {
+  const text = readFileSync(policy, "utf8");
+  if (text.includes("pillars/brand.md")) writeFileSync(policy, text.replaceAll("pillars/brand.md", "marketing/brand.md"));
+}
+
+for (const sub of ["raw/dump", "raw/sources", "ideas", "finance", "customers", "investors", "money", "public"]) {
+  const p = join(dir, sub);
+  if (!existsSync(p)) { mkdirSync(p, { recursive: true }); writeFileSync(join(p, ".gitkeep"), ""); }
+}
+
+const release = {
+  version: 1,
+  at: new Date().toISOString().replace(/\.\d+Z$/, "Z"),
+  note: "Moved onto the package folder layout (EE-070). Old routes stay as aliases for one release.",
+  moves: moved.map(([from, to]) => ({ from, to })),
+  escalated,
+};
+mkdirSync(join(dir, ".release"), { recursive: true });
+const releaseRel = ".release/layout.json";
+writeFileSync(join(dir, releaseRel), JSON.stringify(release, null, 2) + "\n");
+
+const agent = { kind: "agent", id: "grokbot", via: "cli" };
+for (const [from, to] of moved) {
+  record(dir, { entity: to, activity: "move", agent, derived_from: [from], note: `moved from ${from} (EE-070)` });
+}
+record(dir, { entity: releaseRel, activity: "release", agent, derived_from: moved.map(([, to]) => to), note: "package folder layout" });
+
+console.log(`upgraded ${load(join(dir, "venture.json")).id}: ${moved.length} files moved, ${escalated.length} archived for a decision.`);
+for (const e of escalated) console.log(`escalate  ${e}`);

package/schema/use-model.mjs

@@ -0,0 +1,10 @@
+// "use model" (EE-073): a package lists the steps that call a model. A record written
+// downstream of one of those steps carries agent provenance until a person confirms it
+// or its checks pass.
+
+/** "clear" once a person confirmed it or its checks passed. Otherwise "agent". */
+export function provenanceOf({ use_model, confirmed, checksPass }) {
+  if (!Array.isArray(use_model) || use_model.length === 0) return "clear";
+  if (confirmed || checksPass) return "clear";
+  return "agent";
+}

package/schema/validate.py

@@ -0,0 +1,49 @@
+"""Validates every record in the repository against its JSON Schema (EE-017).
+
+    python3 schema/validate.py
+    python3 schema/validate.py --schema <name>.schema.json --file <path>   one file (used by the interfaces before a write)
+
+Needs the jsonschema package (pip install jsonschema). Which files each schema governs comes from schema/data-model.json;
+schema/check-data-model.mjs makes sure no JSON file is left without a record type.
+"""
+import glob, json, sys
+from pathlib import Path
+
+try:
+    import jsonschema
+except ImportError:
+    sys.exit("validate.py needs jsonschema: pip install jsonschema")
+
+root = Path(__file__).resolve().parent.parent
+# The data model names every record type, its schema and where its records live (EE-018).
+# Only JSON records with a schema under schema/ are validated here; the methodology catalog's
+# Markdown records are validated by ee.mjs.
+model = json.loads((root / "schema/data-model.json").read_text())
+RULES = [(r["id"], r["schema"], r.get("form", "json"), r["paths"]) for r in model["records"]
+         if r["schema"] and r["schema"].startswith("schema/") and r.get("form", "json") in ("json", "json-list", "json-lines")]
+from referencing import Registry, Resource
+
+# Every schema is registered by its $id, so one may $ref another (or itself) by file name.
+schemas = {p.name: json.loads(p.read_text()) for p in (root / "schema").glob("*.schema.json")}
+registry = Registry().with_resources((s.get("$id", n), Resource.from_contents(s)) for n, s in schemas.items())
+failed = checked = 0
+if "--file" in sys.argv:
+    one = json.loads(Path(sys.argv[sys.argv.index("--file") + 1]).read_text())
+    v = jsonschema.Draft202012Validator(schemas[sys.argv[sys.argv.index("--schema") + 1]], registry=registry, format_checker=jsonschema.FormatChecker())
+    errs = [f"{'/'.join(map(str, e.absolute_path)) or '(root)'}: {e.message}" for e in v.iter_errors(one)]
+    print("\n".join(errs) if errs else "valid")
+    sys.exit(1 if errs else 0)
+for name, schema, form, globs in RULES:
+    v = jsonschema.Draft202012Validator(schemas[Path(schema).name], registry=registry, format_checker=jsonschema.FormatChecker())
+    for g in globs:
+        for f in sorted(glob.glob(str(root / g), recursive=True)):
+            text = Path(f).read_text()
+            docs = [json.loads(l) for l in text.splitlines() if l.strip()] if form == "json-lines" else json.loads(text)
+            docs = docs if form != "json" else [docs]
+            for d in docs:
+                checked += 1
+                for e in v.iter_errors(d):
+                    failed += 1
+                    print(f"{Path(f).relative_to(root)}: {'/'.join(map(str, e.absolute_path)) or '(root)'}: {e.message}")
+print(f"{checked} records checked against their schemas: {'all valid' if not failed else f'{failed} error(s)'}.")
+sys.exit(1 if failed else 0)