naive-framework 0.1.0 → 0.3.0

package/schema/check-config.mjs

@@ -0,0 +1,111 @@
+#!/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";
+import { ventureFile } from "./venture-paths.mjs";
+
+const FRAMEWORKS = ["idea-map"];
+
+/** Problems with a venture's naive.config.json: { errors, warnings }. */
+export function check(dir) {
+  const errors = [], warnings = [];
+  const f = ventureFile(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(ventureFile(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(ventureFile(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-data-model.mjs

@@ -17,6 +17,7 @@
 import { spawnSync } from "node:child_process";
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { join, relative } from "node:path";
+import { ventureFile } from "./venture-paths.mjs";
 
 // EE_ROOT points the check at another copy of the repository (used by schema/test.mjs).
 const root = process.env.EE_ROOT?.replace(/\/?$/, "/") ?? new URL("..", import.meta.url).pathname;
@@ -26,7 +27,7 @@ const errors = [];
 const warnings = [];
 
 const files = (dir) => readdirSync(join(root, dir), { withFileTypes: true }).flatMap((e) =>
-  [".git", "node_modules", ".naive"].includes(e.name) ? [] : e.isDirectory() ? files(join(dir, e.name)) : [join(dir, e.name)]);
+  [".git", "node_modules", ".naive"].includes(e.name) ? [] : e.isDirectory() ? files(ventureFile(dir, e.name)) : [ventureFile(dir, e.name)]);
 // The files git would track (so build output and installed packages under .gitignore are left out); a
 // copy outside git, as the tests use, is walked instead.
 const tracked = spawnSync("git", ["ls-files", "--cached", "--others", "--exclude-standard"], { cwd: root, encoding: "utf8" });

package/schema/check-data-packages.mjs

@@ -10,6 +10,7 @@
 import { spawnSync } from "node:child_process";
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
+import { ventureFile } from "./venture-paths.mjs";
 
 const dir = process.argv[2];
 if (!dir) { console.error("usage: node schema/check-data-packages.mjs <workspace or venture dir>"); process.exit(2); }
@@ -32,7 +33,7 @@ for (const v of walk(dir)) {
   const id = load(join(v, "venture.json")).id;
   const git = inGit(v);
   for (const pack of PACKS) {
-    const base = join(v, pack);
+    const base = ventureFile(v, pack);
     if (!existsSync(base)) continue;
     for (const name of readdirSync(base)) {
       if (name.startsWith("_") || name.startsWith(".")) continue;
@@ -56,7 +57,7 @@ for (const v of walk(dir)) {
       }
     }
   }
-  const sources = join(v, "raw/sources");
+  const sources = join(ventureFile(v, "raw/sources"));
   if (existsSync(sources)) for (const s of readdirSync(sources)) {
     const sd = join(sources, s);
     if (!statSync(sd).isDirectory() || s.startsWith(".")) continue;
@@ -64,9 +65,9 @@ for (const v of walk(dir)) {
     if (!existsSync(join(sd, "text.md"))) errors.push(`${id}/raw/sources/${s}: missing text.md`);
     for (const f of readdirSync(sd)) if (f.startsWith("original.") && (!git || tracked(v, join("raw/sources", s, f)))) errors.push(`${id}/raw/sources/${s}/${f}: original.* stays out of git`);
   }
-  const map = ["ideas/map.mdx", "purpose/ideas/map.mdx"].map((f) => join(v, f)).find((p) => existsSync(p));
+  const map = ["ideas/map.mdx", "purpose/ideas/map.mdx"].map((f) => ventureFile(v, f)).find((p) => existsSync(p));
   const rawIds = new Set();
-  const dump = join(v, "raw/dump");
+  const dump = join(ventureFile(v, "raw/dump"));
   if (existsSync(dump)) for (const f of readdirSync(dump)) if (f !== ".gitkeep") rawIds.add(f.replace(/\.[^.]+$/, ""));
   if (existsSync(sources)) for (const s of readdirSync(sources)) if (!s.startsWith(".")) rawIds.add(s);
   if (map && rawIds.size) {

package/schema/check-execution.mjs

@@ -13,6 +13,7 @@
 
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
+import { ventureFile } from "./venture-paths.mjs";
 
 const dir = process.argv[2];
 if (!dir) { console.error("usage: node schema/check-execution.mjs <venture dir>"); process.exit(2); }
@@ -27,7 +28,7 @@ const template = load(join(root, "governance/venture-template/decision-rights.js
 const errors = [];
 
 const classes = new Map(template.classes.map((c) => [c.id, c]));
-const own = join(dir, "governance/decision-rights.json");
+const own = join(ventureFile(dir, "governance/decision-rights.json"));
 if (existsSync(own)) for (const c of load(own).classes) {
   const t = classes.get(c.id);
   if (t && RANK[c.level] < RANK[t.level] && !c.decision) errors.push(`decision-rights/${c.id}: loosens ${t.level} to ${c.level} without naming a decision`);
@@ -36,14 +37,14 @@ if (existsSync(own)) for (const c of load(own).classes) {
 for (const c of classes.values()) if (!roles.has(c.owner)) errors.push(`decision-rights/${c.id}: owner ${c.owner} is not a role`);
 
 const results = new Map();
-for (const f of jsonIn(join(dir, "evidence/results"))) {
+for (const f of jsonIn(join(ventureFile(dir, "evidence/results")))) {
   const e = load(f);
   if (e.passed !== e.results.every((r) => r.passed)) errors.push(`evidence/${e.id}: passed says ${e.passed} but its results disagree`);
   results.set(resolve(f), e);
 }
 
 let count = 0;
-for (const f of jsonIn(join(dir, "operations/handoffs"))) {
+for (const f of jsonIn(join(ventureFile(dir, "operations/handoffs")))) {
   const h = load(f), at = `handoff/${h.id}`;
   count++;
   if (h.venture !== venture.id) errors.push(`${at}: venture ${h.venture} is not ${venture.id}`);

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,84 @@
+#!/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";
+import { ventureFile } from "./venture-paths.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(ventureFile(dir, "people/people.json"));
+  const fdir = join(ventureFile(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);
+  // In the structured layout (EE-086) the org chart is venture.json's functions, and a person's hats are the
+  // functions they own there; in the flat layout, the departments venture.json imports, worn as hats in people/.
+  const structured = v.layout === "structured";
+  const imported = new Set(structured ? Object.keys(v.functions ?? {}) : v.departments ?? []);
+  const ids = new Set(roster.people.map((p) => p.id));
+  if (structured) {
+    for (const [fn, f] of Object.entries(v.functions ?? {})) {
+      if (f.owner && !ids.has(f.owner)) at(`venture.json says ${f.owner} owns ${fn}, but people/people.json has no ${f.owner}`);
+      for (const c of f.contributors ?? []) if (!ids.has(c) && !roles.has(c)) at(`${fn} names contributor ${c}, who is neither a person in people/ nor a role`);
+    }
+    for (const p of roster.people) p.hats = Object.entries(v.functions ?? {}).filter(([, f]) => f.owner === p.id).map(([fn]) => fn);
+  }
+  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}`);
+    p.hats ??= [];
+    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(ventureFile(dir, f))) at(`${f} is missing`);
+      else {
+        const rec = load(ventureFile(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 (!structured && JSON.stringify([...(rec.hats ?? [])].sort()) !== JSON.stringify([...p.hats].sort())) at(`${f} and the roster disagree on ${p.id}'s hats`);
+        if (structured && rec.hats) at(`${f} stores hats; in the structured layout they are read from venture.json`);
+        if (rec.agreement && !existsSync(ventureFile(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-private.mjs

@@ -7,6 +7,7 @@
 
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
+import { ventureFile } from "./venture-paths.mjs";
 
 const dir = process.argv[2];
 if (!dir) { console.error("usage: node schema/check-private.mjs <venture dir>"); process.exit(2); }
@@ -49,7 +50,7 @@ for (const { package: name, input } of inputs) {
   if (privateTargets.has(input) || privateRecords.has(input.split(".")[0])) errors.push(`${name}: use_model input ${input} is private and must not reach a model`);
 }
 if (readsRelease) {
-  const release = join(dir, ".release");
+  const release = join(ventureFile(dir, ".release"));
   if (existsSync(release) && statSync(release).isDirectory()) {
     for (const f of walk(release).filter((p) => p.endsWith(".json"))) {
       const text = readFileSync(f, "utf8");

package/schema/check-ready.mjs

@@ -13,19 +13,20 @@
 import { execSync } from "node:child_process";
 import { existsSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { ventureFile } from "./venture-paths.mjs";
 
 const [dir, id] = process.argv.slice(2);
 if (!dir || !id) { console.error("usage: node schema/check-ready.mjs <venture dir> <handoff id> [--record --by <who>]"); process.exit(2); }
 const opt = (k) => process.argv.includes(k) ? process.argv[process.argv.indexOf(k) + 1] : undefined;
 const root = new URL("..", import.meta.url).pathname;
 const load = (p) => JSON.parse(readFileSync(p, "utf8"));
-const hPath = join(dir, "operations/handoffs", `${id}.json`);
+const hPath = join(ventureFile(dir, "operations/handoffs"), `${id}.json`);
 const h = load(hPath);
 const items = [];
 const item = (name, ok, why = "") => items.push({ name, ok, why });
 
 // 1. The brief says what done looks like and what to do, with no placeholders left.
-const bPath = join(dir, "operations/handoffs", h.brief);
+const bPath = join(ventureFile(dir, "operations/handoffs"), h.brief);
 const brief = existsSync(bPath) ? readFileSync(bPath, "utf8") : "";
 item("brief exists", !!brief, bPath);
 const section = (name) => { const m = brief.match(new RegExp(`^##\\s+(?:\\d+\\.\\s*)?${name}\\b[^\\n]*\\n([\\s\\S]*?)(?=^##\\s|$(?![\\s\\S]))`, "mi")); return m ? m[1].trim() : null; };
@@ -34,10 +35,10 @@ const holes = brief.match(/\b(TBD|TODO|FIXME)\b|\?\?\?|<(?:title|role|entity|out
 item("brief has no placeholders left", !holes.length, holes.slice(0, 3).join(", "));
 
 // 2. Everything it names exists.
-const products = new Set(["products", "product"].flatMap((folder) => existsSync(join(dir, folder)) ? readdirSync(join(dir, folder)).filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -5)) : []));
+const products = new Set(["products", "product"].flatMap((folder) => existsSync(ventureFile(dir, folder)) ? readdirSync(ventureFile(dir, folder)).filter((f) => f.endsWith(".json")).map((f) => f.slice(0, -5)) : []));
 const missingProducts = (h.products ?? []).filter((p) => !products.has(p));
 item("every product it serves exists", !missingProducts.length, missingProducts.join(", "));
-const logs = [join(root, "docs/decisions/decisions.json"), join(dir, "knowledge/decisions.json")].filter(existsSync).flatMap((f) => load(f).decisions);
+const logs = [join(root, "docs/decisions/decisions.json"), join(ventureFile(dir, "knowledge/decisions.json"))].filter(existsSync).flatMap((f) => load(f).decisions);
 const decisions = new Map(logs.map((d) => [d.id, d]));
 const badDecisions = (h.governed_by ?? []).filter((d) => !decisions.has(d) || ["withdrawn", "superseded"].includes(decisions.get(d).status));
 item("every governing decision exists and is in force or proposed", !badDecisions.length, badDecisions.join(", "));
@@ -49,7 +50,7 @@ item("every input it needs exists", !missingInputs.length, missingInputs.join(",
 // 3. The holder can act inside its rights.
 const roles = new Set(load(join(root, "governance/venture-template/roles/agent-roles.json")).roles.map((r) => r.id));
 const classes = new Map(load(join(root, "governance/venture-template/decision-rights.json")).classes.map((c) => [c.id, c]));
-const own = join(dir, "governance/decision-rights.json");
+const own = join(ventureFile(dir, "governance/decision-rights.json"));
 if (existsSync(own)) for (const c of load(own).classes) classes.set(c.id, { ...classes.get(c.id), ...c });
 item(`role ${h.role} exists`, roles.has(h.role));
 const foreign = h.decision_classes.filter((c) => classes.get(c)?.owner !== h.role);

package/schema/check-sources.mjs

@@ -11,6 +11,7 @@ import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { LOCAL, MAP, registry } from "../knowledge/connectors/index.mjs";
 import { ANY, CONTEXT, specificity } from "../knowledge/connectors/resolve.mjs";
+import { ventureFile } from "./venture-paths.mjs";
 
 const dir = process.argv[2];
 if (!dir) { console.error("usage: node schema/check-sources.mjs <workspace or venture dir>"); process.exit(2); }
@@ -21,11 +22,13 @@ 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;
 
 for (const v of walk(dir)) {
-  const f = join(v, MAP);
+  const f = ventureFile(v, MAP);
   if (!existsSync(f)) continue;
   maps++;
   const id = JSON.parse(readFileSync(join(v, "venture.json"), "utf8")).id;
@@ -57,10 +60,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/check-where-used.mjs

@@ -10,6 +10,7 @@ import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { connect, sourceFor, sourcesOf } from "../knowledge/connectors/index.mjs";
 import { resolve } from "../interface/router.mjs";
+import { ventureFile } from "./venture-paths.mjs";
 
 const dir = process.argv[2];
 if (!dir) { console.error("usage: node schema/check-where-used.mjs <workspace or venture dir> [--json]"); process.exit(2); }
@@ -21,18 +22,18 @@ const at = (obj, pointer) => pointer.split("/").slice(1).map((k) => k.replace(/~
 const errors = [], drift = [], unchecked = [];
 let lists = 0, checked = 0;
 for (const v of walk(dir)) {
-  if (!existsSync(join(v, FILE))) continue;
+  if (!existsSync(ventureFile(v, FILE))) continue;
   lists++;
   const id = JSON.parse(readFileSync(join(v, "venture.json"), "utf8")).id;
   const ids = new Map(sourcesOf(v).sources.map((s) => [s.id, s]));
-  for (const fact of JSON.parse(readFileSync(join(v, FILE), "utf8")).facts) {
+  for (const fact of JSON.parse(readFileSync(ventureFile(v, FILE), "utf8")).facts) {
     const where = `${id}: ${fact.id}`;
     const { r, params } = resolve(fact.parent.route);
     if (!r || r.kind !== "record" || r.collection === "list") { errors.push(`${where}: parent ${fact.parent.route} is not a record route`); continue; }
     const context = r.collection === "item" && (r.record === "product" || r.record === "account") ? { [r.record]: params.id } : {};
     const src = sourceFor(v, r.record, context);
     const cands = (r.collection === "item" ? r.files.map((f) => f.replace("*", params.id)) : r.files).filter((f) => !f.includes("*"));
-    const path = cands.find((f) => existsSync(join(v, f))) ?? cands[0];
+    const path = cands.find((f) => existsSync(ventureFile(v, f))) ?? cands[0];
     if (src.connector !== "filesystem") { unchecked.push(`${where}: parent is in ${src.id}`); continue; }
     const parent = await (await connect(src, v)).read(path);
     const value = parent && at(JSON.parse(parent.content), fact.parent.pointer);