naive-framework 0.1.0 → 0.2.0

package/schema/check-config.mjs

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+// Checks a venture's naive.config.json (P-2) and explains its gate. Rules: the file matches
+// schema/naive-config.schema.json; rule ids are unique; every route pattern in fail_closed and the
+// rules matches at least one route in the router's table (X-6); every check named in checks exists;
+// every package pinned is installed at that version (U-4); every owner is a role in the team plan
+// when the venture has one; every question setting names a framework that asks System 1 questions.
+//
+//   node schema/check-config.mjs <venture dir> [--json]        check; exit 1 on a problem
+//   node schema/check-config.mjs <venture dir> --resolved      the config with the defaults filled in
+//   node schema/check-config.mjs <venture dir> --rules         every rule the gate applies, and where it comes from
+//   node schema/check-config.mjs <venture dir> --explain <route> [--as person] [--role <id>] [--confidence <n>]
+//                                                              what the gate would do with a write, without writing
+//   node schema/check-config.mjs <venture dir> --pin [<package,...>]
+//                                                              pin packages at their installed versions: the ones
+//                                                              named, else the ones already pinned, else every one
+
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve as resolvePath } from "node:path";
+import { CONFIG, configFor, installed, pinProblems, rawConfig } from "./naive-config.mjs";
+import { evaluate, patternRe, rulesFor } from "./gate.mjs";
+import { teamPlan } from "./access.mjs";
+import { gateOf, repo, resolve, routes } from "../interface/router.mjs";
+import { agentFromEnv, record } from "../interface/provenance.mjs";
+
+const FRAMEWORKS = ["idea-map"];
+
+/** Problems with a venture's naive.config.json: { errors, warnings }. */
+export function check(dir) {
+  const errors = [], warnings = [];
+  const f = join(dir, CONFIG);
+  if (!existsSync(f)) return { errors, warnings, note: `no ${CONFIG}: every default applies` };
+  let raw;
+  try { raw = rawConfig(dir); } catch (e) { return { errors: [e.message], warnings }; }
+  const scratch = mkdtempSync(join(tmpdir(), "naive-config-"));
+  writeFileSync(join(scratch, CONFIG), JSON.stringify(raw));
+  const v = spawnSync("python3", [join(repo, "schema/validate.py"), "--schema", "naive-config.schema.json", "--file", join(scratch, CONFIG)], { encoding: "utf8" });
+  rmSync(scratch, { recursive: true, force: true });
+  if (v.status !== 0) errors.push(`${CONFIG} does not match schema/naive-config.schema.json:\n${(v.stdout + v.stderr).trim()}`);
+  const config = configFor(dir);
+  const table = routes();
+  const known = (p) => !!resolve(p).r || table.some((r) => patternRe(p).test(r.route) || patternRe(p).test(r.route.replace(/\[id\]/g, "x")));
+  const ids = new Set();
+  for (const r of rulesFor(config).filter((x) => x.source === "naive.config.json" && !x.fail_closed)) {
+    if (ids.has(r.id)) errors.push(`gate rule ${r.id}: duplicate id`);
+    ids.add(r.id);
+  }
+  for (const p of config.gate.fail_closed ?? []) if (!known(p) && !known(`${p}/**`)) errors.push(`gate.fail_closed ${p}: matches no route (see node interface/router.mjs --md)`);
+  for (const r of config.gate.rules ?? []) for (const p of r.routes ?? []) if (!known(p)) errors.push(`gate rule ${r.id}: ${p} matches no route`);
+  for (const c of [...(config.checks.off ?? []), ...(config.checks.warn ?? [])]) if (!existsSync(join(repo, c))) errors.push(`checks: ${c} does not exist`);
+  for (const p of pinProblems(config)) errors.push(p.installed ? `packages: ${p.package} is pinned to ${p.pinned} but ${p.installed} is installed` : `packages: ${p.package} is not an installed package`);
+  const plan = teamPlan(dir);
+  for (const [fn, role] of Object.entries(config.owners ?? {})) {
+    if (plan && !(plan.roles ?? []).some((r) => r.id === role)) errors.push(`owners: ${fn} names ${role}, which is not a role in the team plan`);
+    if (!plan) warnings.push(`owners: ${fn} names ${role}, and there is no team plan to check it against`);
+  }
+  for (const fw of Object.keys(config.questions ?? {})) if (!FRAMEWORKS.includes(fw)) errors.push(`questions: ${fw} asks no System 1 questions (one of ${FRAMEWORKS.join(", ")})`);
+  return { errors, warnings };
+}
+
+/** What the gate would do with a write to a route, without writing. */
+export function explain(dir, route, { actor = "agent", role, confidence } = {}) {
+  const { r, params } = resolve(route);
+  if (!r || r.kind !== "record" || !r.actions.includes("write")) throw new Error(`${route} is not a writable record route`);
+  const concrete = r.collection === "item" ? r.route.replace("[id]", params.id) : r.route;
+  const cls = gateOf(r, dir);
+  const files = (r.collection === "item" ? r.files.map((x) => x.replace("*", params.id)) : r.files);
+  const exists = files.some((x) => existsSync(join(dir, x)));
+  const verdict = evaluate({ config: configFor(dir), dir, route: concrete, table: r.route, record: r.record, actor, role, confidence, exists, decisionOwner: cls?.owner ?? undefined });
+  return { route: concrete, record: r.record, actor, role: role ?? null, confidence: confidence ?? null, decision_class: cls ? { class: cls.class, level: cls.level, drafts: cls.drafts && actor !== "person" } : null, gate: verdict };
+}
+
+/** Pins packages at their installed versions and logs the change. Returns the new pins. */
+export function pin(dir, names) {
+  const raw = rawConfig(dir), have = installed();
+  const chosen = names?.length ? names : Object.keys(raw.packages ?? {}).length ? Object.keys(raw.packages) : Object.keys(have);
+  const unknown = chosen.filter((n) => !have[n]);
+  if (unknown.length) throw new Error(`not installed: ${unknown.join(", ")}`);
+  raw.packages = { ...(raw.packages ?? {}), ...Object.fromEntries(chosen.map((n) => [n, have[n]])) };
+  writeFileSync(join(dir, CONFIG), JSON.stringify(raw, null, 2) + "\n");
+  record(dir, { entity: CONFIG, route: "system/naive-config", activity: "write", agent: agentFromEnv("person", "cli"), note: `pinned ${chosen.join(", ")} at the installed versions` });
+  return raw.packages;
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const argv = process.argv.slice(2);
+  const opt = (n) => { const i = argv.indexOf(`--${n}`); return i >= 0 && argv[i + 1] && !argv[i + 1].startsWith("--") ? argv[i + 1] : undefined; };
+  const dir = argv[0] && resolvePath(argv[0]);
+  if (!dir || !existsSync(join(dir, "venture.json"))) { console.error("usage: node schema/check-config.mjs <venture dir> [--json | --resolved | --rules | --explain <route> | --pin [<packages>]]"); process.exit(2); }
+  const out = (x) => console.log(JSON.stringify(x, null, 2));
+  try {
+    if (argv.includes("--resolved")) { out(configFor(dir)); process.exit(0); }
+    if (argv.includes("--rules")) { out(rulesFor(configFor(dir)).map((r) => ({ id: r.id, source: r.source, routes: r.routes, then: r.then, ...(r.when ? { when: r.when } : {}), actors: r.actors ?? ["agent"] }))); process.exit(0); }
+    if (argv.includes("--explain")) {
+      const c = opt("confidence");
+      out(explain(dir, opt("explain"), { actor: opt("as") === "person" ? "person" : "agent", role: opt("role") ?? process.env.MENTURA_ACTOR_ID, confidence: c === undefined ? undefined : Number(c) }));
+      process.exit(0);
+    }
+    if (argv.includes("--pin")) { out({ pinned: pin(dir, opt("pin")?.split(",").filter(Boolean)) }); process.exit(0); }
+  } catch (e) { console.error(String(e.message ?? e)); process.exit(1); }
+  const r = check(dir);
+  if (argv.includes("--json")) out(r);
+  else {
+    for (const w of r.warnings) console.log(`warn  ${w}`);
+    for (const e of r.errors) console.log(`FAIL  ${e}`);
+    if (!r.errors.length) console.log(r.note ?? `${CONFIG} is valid`);
+  }
+  process.exit(r.errors.length ? 1 : 0);
+}

package/schema/check-nextjs-status.mjs

@@ -38,7 +38,9 @@ const counts = Object.fromEntries(STATES.map((s) => [s, count(s)]));
 
 function page() {
   const chapters = [...new Set(data.rows.map((r) => r.chapter))];
-  const cell = (s) => String(s ?? "").replace(/\|/g, "\\|");
+  // MDX reads { and < as code outside backticks, so they are escaped there.
+  const mdx = (t) => t.split(/(`[^`]*`)/).map((x, i) => i % 2 ? x : x.replace(/[{}]/g, (c) => `\\${c}`).replace(/</g, "&lt;").replace(/>/g, "&gt;")).join("");
+  const cell = (s) => mdx(String(s ?? "")).replace(/\|/g, "\\|");
   const lines = [
     "---",
     "title: What's built",

package/schema/check-people.mjs

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+// Checks venture types and people (EE-082) in a workspace: a venture's type is in schema/venture-types.json;
+// in people/people.json every role is in the role registry and allowed for the venture's type, every hat
+// is a function the venture imports, a solo venture has one person who wears every hat, and every
+// founder has a file in people/founders/ that agrees with the roster (and the roster lists every file).
+//
+//   node schema/check-people.mjs <workspace>
+
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { roles as ROLES, types as TYPES } from "./venture-type.mjs";
+
+const ws = process.argv[2];
+if (!ws || !existsSync(ws)) { console.error("usage: node schema/check-people.mjs <workspace>"); process.exit(2); }
+const load = (p) => JSON.parse(readFileSync(p, "utf8"));
+const walk = (d) => readdirSync(d, { withFileTypes: true }).flatMap((e) => e.name === "node_modules" || e.name.startsWith(".") ? []
+  : e.isDirectory() ? walk(join(d, e.name)) : e.name === "venture.json" ? [d] : []);
+
+const types = new Map(TYPES().map((t) => [t.id, t]));
+const roles = new Map(ROLES().map((r) => [r.id, r]));
+const errors = [];
+let ventures = 0, rosters = 0;
+for (const dir of walk(ws)) {
+  ventures++;
+  const v = load(join(dir, "venture.json"));
+  const at = (m) => errors.push(`${v.id}: ${m}`);
+  const type = v.type ? types.get(v.type) : null;
+  if (v.type && !type) at(`type ${v.type} is not in schema/venture-types.json`);
+  const rosterFile = join(dir, "people/people.json");
+  const fdir = join(dir, "people/founders");
+  const files = existsSync(fdir) ? readdirSync(fdir).filter((f) => f.endsWith(".json")) : [];
+  if (!existsSync(rosterFile)) { if (files.length) at("people/founders/ has files but there is no people/people.json"); continue; }
+  rosters++;
+  const roster = load(rosterFile);
+  const imported = new Set(v.departments ?? []);
+  for (const p of roster.people) {
+    const role = roles.get(p.role);
+    if (!role) { at(`${p.id} has role ${p.role}, which is not in governance/venture-template/roles/venture-roles.json`); continue; }
+    if (type && !type.roles.includes(p.role)) at(`${p.id} is a ${p.role}, which a ${type.label.toLowerCase()} does not have (${type.roles.join(", ")})`);
+    for (const h of p.hats) if (imported.size && !imported.has(h)) at(`${p.id} wears the ${h} hat, but venture.json does not import ${h}`);
+    if (!role.owns_when_solo && p.hats.length) at(`${p.id} is a ${p.role}, who owns no function, but wears ${p.hats.join(", ")}`);
+    if (role.founder) {
+      const f = `people/founders/${p.id}.json`;
+      if (p.founder_file !== f) at(`${p.id} is a founder, so founder_file is ${f}`);
+      else if (!existsSync(join(dir, f))) at(`${f} is missing`);
+      else {
+        const rec = load(join(dir, f));
+        if (rec.id !== p.id || rec.role !== p.role) at(`${f} says ${rec.id} is a ${rec.role}; the roster says ${p.id} is a ${p.role}`);
+        if (JSON.stringify([...rec.hats].sort()) !== JSON.stringify([...p.hats].sort())) at(`${f} and the roster disagree on ${p.id}'s hats`);
+        if (rec.agreement && !existsSync(join(dir, rec.agreement.path))) at(`${f} links a founder agreement at ${rec.agreement.path}, which does not exist`);
+      }
+    }
+  }
+  if (roster.mode === "solo") {
+    if (roster.people.length !== 1) at(`a solo venture has one person; people/people.json lists ${roster.people.length}`);
+    else if (roles.get(roster.people[0].role)?.owns_when_solo && imported.size) {
+      const missing = [...imported].filter((h) => !roster.people[0].hats.includes(h));
+      if (missing.length) at(`${roster.people[0].id} is alone, so owns every function; missing ${missing.join(", ")}`);
+    }
+  }
+  if (roster.mode === "team" && imported.size) {
+    const worn = new Set(roster.people.flatMap((p) => p.hats));
+    const unowned = [...imported].filter((h) => !worn.has(h));
+    if (unowned.length) at(`no one owns ${unowned.join(", ")}`);
+  }
+  for (const f of files) if (!roster.people.some((p) => p.founder_file === `people/founders/${f}`)) at(`people/founders/${f} is not in people/people.json`);
+}
+for (const e of errors) console.log(`FAIL  ${e}`);
+console.log(`${ventures} ventures, ${rosters} people rosters: ${errors.length ? `${errors.length} error(s)` : "every role, hat and founder file agrees"}.`);
+process.exit(errors.length ? 1 : 0);

package/schema/check-sources.mjs

@@ -21,6 +21,8 @@ const model = JSON.parse(readFileSync(join(root, "schema/data-model.json"), "utf
 const ventureTypes = new Set(model.records.filter((r) => r.level === "venture").map((r) => r.id));
 const PINNED = new Set(["venture", "provenance", "knowledge-sources"]);
 const reg = registry();
+// The systems a function's truth can live in (EE-083); a connected one must have code that reads it.
+const catalog = JSON.parse(readFileSync(join(root, "schema/systems-catalog.json"), "utf8"));
 const errors = [];
 let maps = 0;
 
@@ -57,10 +59,16 @@ for (const v of walk(dir)) {
     if (!ids.has(rule.system_of_record)) errors.push(`${where}: system of record ${rule.system_of_record} is not one of its sources`);
     for (const s of rule.survivorship?.also_in ?? []) if (!ids.has(s) || s === rule.system_of_record) errors.push(`${where}: survivorship names ${s}, which is not another of its sources`);
   });
+  for (const [fn, f] of Object.entries(m.functions ?? {})) for (const s of f.systems) {
+    const sys = catalog.systems[s.system];
+    if (!sys) { errors.push(`${id}: ${fn} keeps its truth in ${s.system}, which is not in schema/systems-catalog.json`); continue; }
+    if (s.status === "connected" && !sys.connect) errors.push(`${id}: ${fn} says ${s.system} is connected, but no code reads ${sys.label} yet; it is pointed`);
+    if (s.source && !ids.has(s.source)) errors.push(`${id}: ${fn} names source ${s.source}, which is not in sources`);
+  }
   const overlap = (a, b) => a.record === b.record && ["attribute", ...CONTEXT].every((k) => a[k] === ANY || b[k] === ANY || a[k] === b[k]);
   for (let i = 0; i < rules.length; i++) for (let j = i + 1; j < rules.length; j++)
     if (overlap(rules[i], rules[j]) && specificity(rules[i]) === specificity(rules[j]) && rules[i].attribute === rules[j].attribute)
       errors.push(`${id}: rules ${i + 1} and ${j + 1} (${rules[i].record}) can both hold and tie at the same specificity; narrow one`);
 }
 if (errors.length) { console.error(errors.join("\n")); process.exit(1); }
-console.log(`${maps} source maps: every source has a connector, every record type a source, and no two matrix rules tie.`);
+console.log(`${maps} source maps: every source has a connector, every record type a source, every function's systems are known, and no two matrix rules tie.`);

package/schema/data-model.json

@@ -48,7 +48,13 @@
         "exit",
         "telos",
         "provenance",
-        "knowledge-sources"
+        "knowledge-sources",
+        "people",
+        "founder",
+        "fund-thesis",
+        "fund-terms",
+        "deal",
+        "money-summary"
       ],
       "refs": [
         {
@@ -495,6 +501,43 @@
       ],
       "note": "For each fact kept once in its system of record, every place that repeats it; live children must show the parent's value (EE-042)"
     },
+    {
+      "id": "freshness-profiles",
+      "layer": "knowledge",
+      "level": "method",
+      "schema": "schema/freshness-profiles.schema.json",
+      "form": "json",
+      "paths": [
+        "knowledge/freshness.json"
+      ],
+      "refs": [
+        {
+          "field": "records",
+          "to": "(record types)",
+          "checked_by": "schema/freshness-test.mjs"
+        }
+      ],
+      "note": "Default freshness profiles by record type (Revalidating V-2): stale, revalidate and expire after Next.js cacheLife, plus per_phase and live; a venture overrides them under freshness in naive.config.json"
+    },
+    {
+      "id": "freshness-log",
+      "layer": "knowledge",
+      "level": "venture",
+      "schema": "schema/freshness-log.schema.json",
+      "form": "json-lines",
+      "paths": [
+        "instance/**/knowledge/freshness.jsonl",
+        "schema/examples/**/knowledge/freshness.jsonl"
+      ],
+      "refs": [
+        {
+          "field": "target.value",
+          "to": "(venture file)",
+          "checked_by": "schema/freshness.mjs"
+        }
+      ],
+      "note": "On-demand revalidations (a tag, a path or a package marked stale), checks that a record is still right, and phase changes: one append-only line each (Revalidating V-1, V-5, V-7)"
+    },
     {
       "id": "department-catalog",
       "layer": "operations",
@@ -979,6 +1022,24 @@
       ],
       "note": "Venture packages (EE-067, EE-069): the assumed governance model; core packages by department (each record's one home, what it reads, priors per phase with conditions, what completion unlocks); handoff packages by receiver; record-level dependencies; the question matrix"
     },
+    {
+      "id": "frame",
+      "layer": "system",
+      "level": "method",
+      "schema": "schema/frame.schema.json",
+      "form": "json",
+      "paths": [
+        "packages/*/frames/*.frame.json"
+      ],
+      "refs": [
+        {
+          "field": "emits.*.id",
+          "to": "decision",
+          "checked_by": "schema/frames-test.mjs"
+        }
+      ],
+      "note": "The decision library: one recurring venture problem as a shape (goal, hidden decisions, premises and the attacks on them, a freshness spec, reasoning), never an answer. schema/frames.mjs matches it to the founder's words, judges its premises against the venture and proposes its decisions, open"
+    },
     {
       "id": "venture-package",
       "layer": "system",
@@ -992,6 +1053,18 @@
       ],
       "note": "The venture package view (EE-067, EE-069): the open core packages and handoffs, each record confirmed, to review or to write, what moves now and what waits, with its versions; the records themselves stay in place"
     },
+    {
+      "id": "release",
+      "layer": "system",
+      "level": "venture",
+      "schema": null,
+      "form": "json",
+      "paths": [
+        "instance/**/.release/release.json",
+        "instance/**/.release/card.json"
+      ],
+      "note": "A release (C-11, I-17): the venture's static shell, written by node schema/build-release.mjs. release.json is the manifest (confirmed records frozen in with their sha256, date and who confirmed them; named live holes; the route table as the release holds it; frozen command answers); card.json is the release card's data (P-25, O-7). The frozen copies under .release/records/ keep their own record types. Read without the router by node schema/start-release.mjs"
+    },
     {
       "id": "team-plan",
       "layer": "operations",
@@ -1063,6 +1136,35 @@
       ],
       "note": "Who or what wrote each record, how, from what and under which decision: one append-only line per write, hash-chained, after W3C PROV (EE-031)"
     },
+    {
+      "id": "naive-config",
+      "layer": "system",
+      "level": "venture",
+      "schema": "schema/naive-config.schema.json",
+      "paths": [
+        "instance/**/naive.config.json",
+        "schema/examples/**/naive.config.json"
+      ],
+      "decision_class": "security-loosening",
+      "refs": [
+        {
+          "field": "gate.rules.routes",
+          "to": "(routes)",
+          "checked_by": "schema/check-config.mjs"
+        },
+        {
+          "field": "owners",
+          "to": "team-plan",
+          "checked_by": "schema/check-config.mjs"
+        },
+        {
+          "field": "packages",
+          "to": "venture-packages",
+          "checked_by": "schema/check-config.mjs"
+        }
+      ],
+      "note": "The venture's overrides to Naive's defaults (P-2, like next.config.js): the gate's static rules, function owners, check settings, thresholds, which System 1 questions run, pinned package versions and how strictly the acting role is checked. An agent's write of it is a draft, since it can loosen the gate"
+    },
     {
       "id": "route-aliases",
       "layer": "interface",
@@ -1073,6 +1175,51 @@
       ],
       "note": "Old routes kept as aliases of their new ones, so a rename does not break agents (EE-032)"
     },
+    {
+      "id": "adapter",
+      "layer": "interface",
+      "level": "method",
+      "schema": "schema/adapter.schema.json",
+      "paths": [
+        "interface/adapters/*.json",
+        "platform/adapter.json"
+      ],
+      "note": "What runs Naive on a platform or in an agent harness (Z-4): the entry files a harness adapter writes into a venture and where it loads skills, or the tests a platform adapter runs. Verified when it passes the framework's tests (interface/adapters.mjs verify)"
+    },
+    {
+      "id": "upgrade-registry",
+      "layer": "system",
+      "level": "method",
+      "schema": "schema/upgrade-registry.schema.json",
+      "paths": [
+        "schema/upgrades.json"
+      ],
+      "refs": [
+        {
+          "field": "versions[].guide",
+          "to": "(repository file)",
+          "checked_by": "schema/upgrades-test.mjs"
+        }
+      ],
+      "note": "Naive's versions with their guides, the migrations between them, and each package's version and channel (U-1 to U-6, EE-076). naive upgrade reads it from the installed copy"
+    },
+    {
+      "id": "kit",
+      "layer": "system",
+      "level": "method",
+      "schema": "schema/kit.schema.json",
+      "paths": [
+        "platform/kits/*/kit.json"
+      ],
+      "refs": [
+        {
+          "field": "extends.package",
+          "to": "venture-packages",
+          "checked_by": null
+        }
+      ],
+      "note": "A Mentura kit (EE-071): an enhanced package or command, with its automations (triggers that need a complete package, M-12) or its agent workflow (the agent-run upgrade, U-3). The framework reads it as data and never imports its code (schema/kits.mjs)"
+    },
     {
       "id": "icp",
       "layer": "purpose",
@@ -1158,6 +1305,17 @@
       ],
       "note": "A money master record. Activity is an append-only stream. The package is never complete (EE-070)."
     },
+    {
+      "id": "money-summary",
+      "layer": "purpose",
+      "level": "venture",
+      "schema": "schema/money-summary.schema.json",
+      "paths": [
+        "instance/**/money/_summary.json",
+        "schema/examples/**/money/_summary.json"
+      ],
+      "note": "Cash, monthly flows and runway from the money source's last sync; versioned, and the only money record a model sees (EE-070)"
+    },
     {
       "id": "data-stream",
       "layer": "purpose",
@@ -1195,17 +1353,177 @@
         "schema/examples/**/raw/sources/*/text.md"
       ],
       "note": "The text of a raw source. original.* stays out of git (EE-070)."
-    }
-  ],
-  "ignore": [
+    },
     {
-      "path": "package.json",
-      "reason": "The framework's npm manifest: the naive and mentura commands (I-1, I-17); not a record"
+      "id": "judgment",
+      "layer": "knowledge",
+      "level": "venture",
+      "schema": "schema/judgment.schema.json",
+      "paths": [
+        "instance/**/knowledge/judgments/*.json",
+        "schema/examples/**/knowledge/judgments/*.json"
+      ],
+      "refs": [
+        {
+          "field": "package",
+          "to": "(packages and kits)",
+          "checked_by": "schema/model-steps.mjs"
+        },
+        {
+          "field": "decision",
+          "to": "decision-record",
+          "checked_by": "schema/model-steps.mjs"
+        }
+      ],
+      "note": "The typed output of one model step (use model, EE-073): what it read, its answer and confidence, and whether code accepted, overruled or routed it to a person as uncertain. The agent's until a person confirms it (schema/model-steps.mjs)"
     },
     {
-      "path": "interface/create-venture/package.json",
-      "reason": "The create-venture generator's npm manifest (I-1); not a record"
+      "id": "venture-types",
+      "layer": "system",
+      "level": "method",
+      "schema": "schema/venture-types.schema.json",
+      "paths": [
+        "schema/venture-types.json"
+      ],
+      "note": "The venture types create-venture scaffolds, and what each starts with (EE-082)"
+    },
+    {
+      "id": "venture-role",
+      "layer": "governance",
+      "level": "method",
+      "schema": "schema/venture-role.schema.json",
+      "paths": [
+        "governance/venture-template/roles/venture-roles.json"
+      ],
+      "note": "Roles a person can hold in a venture, beside the agent roles (EE-082)"
+    },
+    {
+      "id": "people",
+      "layer": "operations",
+      "level": "venture",
+      "schema": "schema/people.schema.json",
+      "paths": [
+        "instance/**/people/people.json",
+        "schema/examples/**/people/people.json"
+      ],
+      "note": "The venture's people: role and hats per person; venture.json for human capital (EE-082)"
     },
+    {
+      "id": "founder",
+      "layer": "operations",
+      "level": "venture",
+      "schema": "schema/founder.schema.json",
+      "paths": [
+        "instance/**/people/founders/*.json",
+        "schema/examples/**/people/founders/*.json"
+      ],
+      "note": "One file per founder, linked to the founder agreement (EE-082)"
+    },
+    {
+      "id": "fund-thesis",
+      "layer": "purpose",
+      "level": "venture",
+      "schema": "schema/fund-thesis.schema.json",
+      "paths": [
+        "instance/**/fund/thesis.json",
+        "schema/examples/**/fund/thesis.json"
+      ],
+      "note": "A fund's thesis (EE-082)"
+    },
+    {
+      "id": "fund-terms",
+      "layer": "purpose",
+      "level": "venture",
+      "schema": "schema/fund-terms.schema.json",
+      "paths": [
+        "instance/**/fund/terms.json",
+        "schema/examples/**/fund/terms.json"
+      ],
+      "note": "A fund's terms and closes (EE-082)"
+    },
+    {
+      "id": "deal",
+      "layer": "purpose",
+      "level": "venture",
+      "schema": "schema/deal.schema.json",
+      "paths": [
+        "instance/**/deals/*.json",
+        "schema/examples/**/deals/*.json"
+      ],
+      "note": "A company in a fund's pipeline (EE-082)"
+    },
+    {
+      "id": "systems-catalog",
+      "layer": "knowledge",
+      "level": "method",
+      "schema": "schema/systems-catalog.schema.json",
+      "paths": [
+        "schema/systems-catalog.json"
+      ],
+      "note": "The systems of record create-venture offers per function (EE-083)"
+    },
+    {
+      "id": "glossary",
+      "layer": "knowledge",
+      "level": "venture",
+      "schema": "schema/glossary.schema.json",
+      "paths": [
+        "instance/**/glossary/*.json",
+        "schema/examples/**/glossary/*.json"
+      ],
+      "refs": [
+        {
+          "field": "terms[].export",
+          "to": "glossary",
+          "checked_by": "schema/check-brand.mjs"
+        }
+      ],
+      "note": "A package's own terms, at glossary/<package>.json (Y-2): local to the package unless exported, so an agent in another package sees only exported terms; glossary/terms shows what one package sees"
+    },
+    {
+      "id": "marketing-brand",
+      "layer": "operations",
+      "level": "venture",
+      "schema": "schema/marketing-brand.schema.json",
+      "paths": [
+        "instance/**/marketing/brand.json",
+        "schema/examples/**/marketing/brand.json"
+      ],
+      "refs": [
+        {
+          "field": "marks[].asset",
+          "to": "public-assets",
+          "checked_by": "schema/check-brand.mjs"
+        },
+        {
+          "field": "typefaces[].files",
+          "to": "public-assets",
+          "checked_by": "schema/check-brand.mjs"
+        }
+      ],
+      "decision_class": "experience-design",
+      "note": "Brand tokens in the marketing package (Y-3): colors, licensed self-hosted typefaces (T-1), the font each role uses with scopes where nearer context wins (Y-5, T-2), voice rules (the global stylesheet for words), the logo and marks (P-24) and outside design systems by reference (Y-4). Read by every agent's layout; marketing/brand/tokens renders it for interfaces"
+    },
+    {
+      "id": "public-assets",
+      "layer": "operations",
+      "level": "venture",
+      "schema": "schema/public-assets.schema.json",
+      "paths": [
+        "instance/**/public/assets.json",
+        "schema/examples/**/public/assets.json"
+      ],
+      "refs": [
+        {
+          "field": "remote[].id",
+          "to": "raw-source",
+          "checked_by": "schema/check-assets.mjs"
+        }
+      ],
+      "note": "The register of what the venture ships as it is, in public/ (I-23, J-2, J-3, J-4): each file's source, license and credit, facts code reads from its bytes, alt text and who wrote it; remote images as links with a note in raw/; the hosts an agent may fetch from"
+    }
+  ],
+  "ignore": [
     {
       "path": "site/package.json",
       "reason": "The developer-docs site's npm manifest (EE-034); not a record"
@@ -1253,6 +1571,14 @@
     {
       "path": "site/content/marketing/meta.json",
       "reason": "Fumadocs sidebar order for marketing pages (EE-080); not a record"
+    },
+    {
+      "path": "package.json",
+      "reason": "The framework's npm manifest: the naive and mentura commands (I-1, I-17); not a record"
+    },
+    {
+      "path": "interface/create-venture/package.json",
+      "reason": "The create-venture generator's npm manifest (I-1); not a record"
     }
   ]
 }