naive-framework 0.1.0 → 0.3.0

package/schema/fund-thesis.schema.json

@@ -0,0 +1,87 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "fund-thesis.schema.json",
+  "title": "Fund thesis",
+  "description": "What a fund invests in and why it wins (fund/thesis.json): rounds, sectors, geographies, check size, and the edge. The fund's strategic foundation, as the problem record is a startup's.",
+  "type": "object",
+  "required": [
+    "venture",
+    "statement",
+    "rounds",
+    "sectors",
+    "check_size"
+  ],
+  "additionalProperties": false,
+  "properties": {
+    "venture": {
+      "type": "string"
+    },
+    "statement": {
+      "type": "string",
+      "description": "The thesis in one or two sentences"
+    },
+    "rounds": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "enum": [
+          "pre-seed",
+          "seed",
+          "series-a",
+          "series-b",
+          "growth",
+          "late"
+        ]
+      }
+    },
+    "sectors": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "string"
+      }
+    },
+    "geographies": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "check_size": {
+      "type": "object",
+      "required": [
+        "min",
+        "max",
+        "currency"
+      ],
+      "additionalProperties": false,
+      "properties": {
+        "min": {
+          "type": "number",
+          "minimum": 0
+        },
+        "max": {
+          "type": "number",
+          "minimum": 0
+        },
+        "currency": {
+          "type": "string",
+          "pattern": "^[A-Z]{3}$"
+        }
+      }
+    },
+    "ownership_target": {
+      "type": "number",
+      "minimum": 0,
+      "maximum": 1,
+      "description": "Target ownership at entry, as a fraction"
+    },
+    "edge": {
+      "type": "string",
+      "description": "Why this fund sees, wins or helps deals others do not"
+    },
+    "why_now": {
+      "type": "string"
+    }
+  }
+}

package/schema/gate-drafts.mjs

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+// Held writes (X-2): where the gate's drafts wait and for whom. The gate (schema/gate.mjs) decides;
+// this stores what it held. A held write lands in _drafts/ as before, with a sidecar
+// (<draft>.gate) saying which rule held it and the function owner it was sent to. Where a rule (or
+// gate.variants in naive.config.json) keeps variants, a second agent draft that differs from the
+// first is kept beside it instead of replacing it, like an A/B rewrite: variant a is <draft>,
+// variant b is <draft>.b, and so on. One open decision, in the decisions/ folder beside the record,
+// asks the founder which to accept. Accepting one variant (mentura accept <route> --pick b) decides
+// that decision and removes the others.
+//
+//   node schema/gate-drafts.mjs <venture dir> [--owner <role>] [--json]   the drafts waiting, by owner
+
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { approve } from "./decisions.mjs";
+import { ventureFile } from "./venture-paths.mjs";
+
+const sha = (s) => createHash("sha256").update(s).digest("hex");
+const LETTERS = "abcdefghijklmnopqrstuvwxyz";
+export const sidecarOf = (draft) => `${draft}.gate`;
+export const variantPath = (draft, v) => (v === "a" ? draft : `${draft}.${v}`);
+
+/** The decision that holds a record's variants side by side: its id and venture-relative file. */
+export function variantsDecision(file) {
+  const stem = file.replace(/\.json$/, "");
+  const id = `variants-${stem.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "")}`;
+  const at = dirname(file) === "." ? "decisions" : `${dirname(file)}/decisions`;
+  return { id, path: `${at}/${basename(stem)}.variants.decision.json` };
+}
+
+const readJson = (f) => JSON.parse(readFileSync(f, "utf8"));
+
+/** The sidecar of a draft, or null. */
+export function sidecar(dir, draft) {
+  const f = join(dir, sidecarOf(draft));
+  return existsSync(f) ? readJson(f) : null;
+}
+
+/**
+ * Stores a held write. dir: the venture; draft: _drafts/<file>.draft; file: the record's path; text:
+ * the record; verdict: the gate's, or null when only a decision class held it; route; agent: who wrote it.
+ * Returns { written, variant, variants, decision }.
+ */
+export function writeHeld(dir, { draft, file, text, verdict, route, agent = {} }) {
+  const dest = ventureFile(dir, draft);
+  mkdirSync(dirname(dest), { recursive: true });
+  const at = new Date().toISOString();
+  const by = agent.id ?? agent.kind ?? "agent";
+  const meta = sidecar(dir, draft);
+  const keep = !!verdict?.variants && existsSync(dest);
+  if (!keep) {
+    writeFileSync(dest, text);
+    for (const v of meta?.variants ?? []) if (v.variant !== "a") rmSync(join(dir, variantPath(draft, v.variant)), { force: true });
+    if (verdict && verdict.then !== "pass") {
+      writeFileSync(join(dir, sidecarOf(draft)), JSON.stringify({ route, file, rule: verdict.rule, source: verdict.source, then: verdict.then,
+        ...(verdict.owner ? { owner: verdict.owner, function: verdict.function ?? null } : {}), variants: [{ variant: "a", file: draft, by, at, sha256: sha(text) }] }, null, 2) + "\n");
+    } else rmSync(join(dir, sidecarOf(draft)), { force: true });
+    return { written: draft, variant: "a" };
+  }
+  // Variants: the first draft stays as a; a draft equal to one already held is that variant.
+  const variants = meta?.variants?.length ? meta.variants : [{ variant: "a", file: draft, by: "agent", at, sha256: sha(readFileSync(dest)) }];
+  const same = variants.find((v) => v.sha256 === sha(text));
+  if (same) return { written: same.file, variant: same.variant, variants: variants.map((v) => v.variant), decision: meta?.decision ?? null };
+  const next = LETTERS[variants.length];
+  if (!next) throw new Error(`${route} already holds ${variants.length} drafts side by side; accept one first`);
+  const vfile = variantPath(draft, next);
+  writeFileSync(ventureFile(dir, vfile), text);
+  variants.push({ variant: next, file: vfile, by, at, sha256: sha(text) });
+  const dec = variantsDecision(file);
+  const record = {
+    id: dec.id,
+    question: `Which draft of ${route} do you accept?`,
+    decides: { path: file },
+    parent: "venture",
+    boundary: "fail-open",
+    status: "open",
+    options: variants.map((v) => `${v.variant}: drafted by ${v.by} at ${v.at}`),
+    answer: null,
+    note: `The gate kept ${variants.length} differing drafts side by side (rule ${verdict.rule}). Accept one: mentura accept ${route} --pick <letter>`,
+    provenance: { drafted_by: { kind: "framework" } },
+  };
+  mkdirSync(dirname(ventureFile(dir, dec.path)), { recursive: true });
+  writeFileSync(ventureFile(dir, dec.path), JSON.stringify(record, null, 2) + "\n");
+  writeFileSync(join(dir, sidecarOf(draft)), JSON.stringify({ ...(meta ?? { route, file, rule: verdict.rule, source: verdict.source, then: verdict.then, ...(verdict.owner ? { owner: verdict.owner, function: verdict.function ?? null } : {}) }), variants, decision: dec.id }, null, 2) + "\n");
+  return { written: vfile, variant: next, variants: variants.map((v) => v.variant), decision: dec.id };
+}
+
+/** The file of one variant of a draft, to accept. Throws when a draft holds variants and none, or an unknown one, is picked. */
+export function pick(dir, draft, letter) {
+  const meta = sidecar(dir, draft);
+  const vs = meta?.variants ?? [];
+  if (vs.length > 1 && !letter) throw new Error(`${meta.route} holds ${vs.length} drafts side by side (${vs.map((v) => v.variant).join(", ")}): pick one with --pick <letter>`);
+  if (!letter || letter === "a") return draft;
+  const v = vs.find((x) => x.variant === letter);
+  if (!v) throw new Error(`no draft ${letter} of ${meta?.route ?? draft}${vs.length ? ` (there are ${vs.map((x) => x.variant).join(", ")})` : ""}`);
+  return v.file;
+}
+
+/** After a person accepts a draft: removes every variant and the sidecar, and decides the variants decision. */
+export function settle(dir, draft, { picked = "a", by } = {}) {
+  const meta = sidecar(dir, draft);
+  for (const v of meta?.variants ?? []) rmSync(ventureFile(dir, v.file), { force: true });
+  rmSync(ventureFile(dir, draft), { force: true });
+  rmSync(join(dir, sidecarOf(draft)), { force: true });
+  if (!meta?.decision) return { picked };
+  const d = approve(dir, meta.decision, { by: by ?? process.env.MENTURA_PERSON ?? "founder", answer: picked, note: `accepted draft ${picked} of ${meta.route}` });
+  return { picked, decision: meta.decision, decided: d.ok, ...(d.ok ? {} : { error: d.error }) };
+}
+
+/** The drafts waiting in a venture: route, rule, owner and variants. A draft with no sidecar was held by its decision class. */
+export function inbox(dir, owner) {
+  const d = join(ventureFile(dir, "_drafts"));
+  if (!existsSync(d)) return [];
+  return readdirSync(d).filter((f) => f.endsWith(".draft")).sort().map((f) => {
+    const draft = `_drafts/${f}`;
+    const meta = sidecar(dir, draft);
+    return { draft, file: f.replace(/\.draft$/, "").replace(/__/g, "/"), route: meta?.route ?? null, rule: meta?.rule ?? null, then: meta?.then ?? "draft",
+      owner: meta?.owner ?? null, variants: (meta?.variants ?? [{ variant: "a" }]).map((v) => v.variant), decision: meta?.decision ?? null };
+  }).filter((x) => !owner || x.owner === owner);
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const [dir] = process.argv.slice(2).filter((a, i, all) => !a.startsWith("--") && !(i && all[i - 1] === "--owner"));
+  if (!dir || !existsSync(join(dir, "venture.json"))) { console.error("usage: node schema/gate-drafts.mjs <venture dir> [--owner <role>] [--json]"); process.exit(2); }
+  const i = process.argv.indexOf("--owner");
+  const rows = inbox(dir, i > 0 ? process.argv[i + 1] : undefined);
+  if (process.argv.includes("--json")) console.log(JSON.stringify(rows, null, 2));
+  else if (!rows.length) console.log("no drafts waiting");
+  else for (const r of rows) console.log(`${r.file.padEnd(36)} ${r.then.padEnd(6)} ${r.owner ?? "-"}  ${r.rule ?? "decision class"}  variants ${r.variants.join(", ")}`);
+}

package/schema/gate.mjs

@@ -1,14 +1,24 @@
-// The gate (EE-073): checks that run before a write. One per venture. Static rules live in
-// naive.config.json. Per-package rules are the gates on each package definition. The gate
-// matches the router's path patterns and never calls a model. Confidence routing reads a
-// score that was already computed.
+// The gate (EE-073, P-5, X-1 to X-6): what happens to a write before it lands. One gate per venture
+// (X-5). Its rules come from three places: the venture's naive.config.json (fail_closed routes and
+// rules), each package's gate_rules in its package definition (imported, unless the config leaves a
+// package out), and two the framework always applies: pinned package versions (U-4) and the acting
+// role's write access (P-27). A rule names the routes it covers in the router's own path patterns
+// (X-6) and says what happens: hold the write as a draft, send it as a draft to the function owner
+// (X-2), or refuse it.
+//
+// The gate is fast and never calls a model (X-4). Confidence routing reads a score the write already
+// carries; a write without a score is never held for confidence. Access is checked here and again
+// at the record by the router, on every read and write (F-5). The gate decides; storing a held
+// write, and keeping differing drafts side by side, is schema/gate-drafts.mjs.
 
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { join } from "node:path";
+import { may } from "./access.mjs";
+import { configFor, functionOf, packageDefs, packagesOf, pinsBlocking, threshold } from "./naive-config.mjs";
 
 const repo = new URL("..", import.meta.url).pathname;
 
-/** Package gates, imported from packages/<name>/package.json. No model, no network. */
+/** Package gates, imported from packages/<name>/package.json: the completion gates, as written. No model, no network. */
 export function packageGates() {
   const dir = join(repo, "packages");
   if (!existsSync(dir)) return [];
@@ -21,8 +31,8 @@ export function packageGates() {
 }
 
 /**
- * Whether an agent write is held as a draft. fail_closed names path prefixes
- * (foundation, or foundation/problem). A person is not held.
+ * Whether an agent write is held as a draft by fail_closed alone. fail_closed names path prefixes
+ * (foundation, or foundation/problem). A person is not held. Kept for callers of the first gate.
  */
 export function hold(config, route, actor) {
   if (actor === "person") return null;
@@ -31,9 +41,93 @@ export function hold(config, route, actor) {
   return hit ? { hold: "draft", rule: hit } : null;
 }
 
-/** The venture's naive.config.json, or an empty config. */
+/** The gate section of the venture's naive.config.json, with its defaults. */
 export function configOf(dir) {
-  const f = dir && join(dir, "naive.config.json");
-  if (!f || !existsSync(f)) return { fail_closed: [] };
-  return JSON.parse(readFileSync(f, "utf8")).gate ?? { fail_closed: [] };
+  return configFor(dir).gate;
+}
+
+/**
+ * A route pattern as a regular expression, in the router's own path syntax (X-6): a plain route
+ * matches itself; an [id] (any [name]) segment or * is one segment; ** is any depth, and a trailing
+ * /** covers the route above it too (validation/** covers validation).
+ */
+export function patternRe(pattern) {
+  const segs = pattern.split("/").filter(Boolean);
+  let re = "", sep = false;
+  segs.forEach((s, i) => {
+    if (s === "**") {
+      if (i === segs.length - 1) re += sep ? "(?:/.*)?" : ".*";
+      else { re += sep ? "(?:/[^/]+)*/" : "(?:[^/]+/)*"; sep = false; }
+      return;
+    }
+    re += (sep ? "/" : "") + (/^\[[a-z.]+\]$/.test(s) || s === "*" ? "[^/]+" : s.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]*"));
+    sep = true;
+  });
+  return new RegExp(`^${re}$`);
+}
+
+/** Whether a rule's pattern covers a write: the concrete route (product/kettle) or its table route (product/[id]). */
+export function matches(pattern, route, tableRoute) {
+  const re = patternRe(pattern);
+  return re.test(route) || (!!tableRoute && (pattern === tableRoute || re.test(tableRoute)));
+}
+
+/** Gate rules imported from the package definitions (X-5): each package's gate_rules, tagged with the package. */
+export function packageRules(config) {
+  const sel = config?.gate?.packages ?? true;
+  if (sel === false) return [];
+  return packageDefs().filter((p) => sel === true || sel[p.name] !== false)
+    .flatMap((p) => (p.gate_rules ?? []).map((r) => ({ ...r, source: `package ${p.name}`, package: p.name })));
+}
+
+/** Every rule the venture's gate applies, in order: fail_closed, the config's rules, then the packages'. */
+export function rulesFor(config) {
+  const g = config?.gate ?? {};
+  return [
+    ...(g.fail_closed ?? []).map((p) => ({ id: p, routes: [p, `${p}/**`], then: "draft", actors: ["agent"], source: "naive.config.json", fail_closed: true })),
+    ...(g.rules ?? []).map((r) => ({ ...r, source: "naive.config.json" })),
+    ...packageRules(config),
+  ];
+}
+
+const SEVERITY = { pass: 0, draft: 1, owner: 2, refuse: 3 };
+
+/**
+ * The gate's verdict on one write. Input: config (resolved, from configFor), dir (for access),
+ * route (concrete), table (its route-table pattern), record (type), actor (person or agent), role
+ * (team-plan id), confidence (a score the write carries, or undefined), exists (the record exists
+ * now), decisionOwner (the owner of the record's decision class, if any).
+ * Returns { then: pass | draft | owner | refuse, rule, source, owner, variants, why, matched }.
+ */
+export function evaluate({ config, dir, route, table, requested, record, actor = "agent", role, confidence, exists, decisionOwner }) {
+  const pins = pinsBlocking(config, record);
+  if (pins.length) return { then: "refuse", rule: "pinned-version", source: "naive.config.json packages", matched: ["pinned-version"],
+    why: pins.map((p) => `${p.package} is pinned to ${p.pinned} but ${p.installed ?? "nothing"} is installed`).join("; ") + ": change the pin or the install first" };
+  if (dir && role && ![route, table, requested].some((x) => x && may(dir, role, "write", x)))
+    return { then: "refuse", rule: "access", source: "team plan", matched: ["access"], why: `${role} may not write ${route} (team plan routes)` };
+  const hits = [];
+  for (const r of rulesFor(config)) {
+    if (!(r.actors ?? ["agent"]).includes(actor)) continue;
+    if (r.roles?.length && !r.roles.includes(role)) continue;
+    if (!r.routes.some((p) => matches(p, route, table))) continue;
+    const w = r.when ?? {};
+    if (w.exists !== undefined && w.exists !== !!exists) continue;
+    if (w.confidence_below !== undefined) {
+      const limit = typeof w.confidence_below === "number" ? w.confidence_below : threshold(config, w.confidence_below, threshold(config, "confidence", 0.7));
+      if (typeof confidence !== "number" || confidence >= limit) continue;
+    }
+    hits.push(r);
+  }
+  if (!hits.length) return { then: "pass", rule: null, source: null, matched: [] };
+  const top = hits.reduce((a, b) => (SEVERITY[b.then] > SEVERITY[a.then] ? b : a));
+  const fn = functionOf(record);
+  // The owner: the rule's, else naive.config.json owners by function or by package, else the record's decision-class owner, else the founder.
+  const keys = [fn, top.package, ...packagesOf(record).map((p) => p.name)].filter(Boolean);
+  const owner = top.then === "owner" ? top.owner ?? keys.map((k) => config?.owners?.[k]).find(Boolean) ?? decisionOwner ?? "founder" : undefined;
+  const variants = !!(top.variants ?? config?.gate?.variants);
+  const where = top.fail_closed ? `${top.id} fails closed in naive.config.json` : `rule ${top.id} (${top.source})`;
+  const why = top.then === "refuse" ? `${where} refuses this write${top.note ? `: ${top.note}` : ""}`
+    : top.then === "owner" ? `${where} sends this write to its function owner, ${owner}: written as a draft for them to accept`
+    : `${where}: written as a draft for a person to accept`;
+  return { then: top.then, rule: top.id, source: top.source, ...(owner ? { owner, function: fn } : {}), variants, why, matched: hits.map((h) => h.id) };
 }

package/schema/glossary.schema.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "glossary.schema.json",
+  "title": "Package glossary",
+  "description": "A package's own terms, at glossary/<package>.json (Y-2, the scoping idea of CSS Modules): each term stays local to the package unless export is true, so an agent working in another package sees only exported terms. Two packages exporting one term with different meanings fail schema/check-brand.mjs. Version 0.x, unevaluated.",
+  "type": "object",
+  "required": ["package", "terms"],
+  "additionalProperties": false,
+  "properties": {
+    "package": { "type": "string", "pattern": "^[a-z0-9][a-z0-9-]*$", "description": "The package whose terms these are; the file is glossary/<package>.json" },
+    "terms": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["term", "meaning"],
+        "additionalProperties": false,
+        "properties": {
+          "term": { "type": "string", "minLength": 1 },
+          "meaning": { "type": "string", "minLength": 1 },
+          "export": { "type": "boolean", "description": "true: other packages see it too" }
+        }
+      }
+    }
+  }
+}

package/schema/init-venture.mjs

@@ -3,6 +3,11 @@
 // (EE-011). Starting layers come from scaffold/defaults.json, by phase (EE-012).
 //
 //   node schema/init-venture.mjs <dir> <id> [--phase discovery] [--parent <id>] [--legal-form llc] [--layers purpose,governance]
+//                                [--type <venture type>]
+//
+// --type (schema/venture-types.json, EE-082) decides the package folders, the functions venture.json
+// imports and the first decisions: a software startup answers the product questions, a VC fund its
+// thesis and terms. Without it, every package folder is made and the product questions are asked.
 //
 // --layers turns on only the layers named, for a builder adopting part of the system (EE-030);
 // without it the phase's defaults apply.
@@ -10,48 +15,68 @@
 // Creates new ventures only, like create-next-app: it refuses a directory that exists and is not empty,
 // so it can never overwrite a founder's files. An existing project comes in through naive port (EE-076).
 
+import { spawnSync } from "node:child_process";
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join, relative } from "node:path";
 import { fileURLToPath } from "node:url";
+import { ventureFile } from "./venture-paths.mjs";
 
 const here = dirname(fileURLToPath(import.meta.url));
 const repo = join(here, "..");
 const { layers, formalized, pillars, readme } = JSON.parse(readFileSync(join(here, "scaffold/defaults.json"), "utf8"));
 const args = process.argv.slice(2);
 const flag = (name) => { const i = args.indexOf(`--${name}`); return i < 0 ? null : args.splice(i, 2)[1]; };
-const phase = flag("phase") ?? "discovery", parent = flag("parent"), legalForm = flag("legal-form"), only = flag("layers");
+const phase = flag("phase") ?? "discovery", parent = flag("parent"), legalForm = flag("legal-form"), only = flag("layers"), typeId = flag("type");
+// --layout structured (EE-086): knowledge/, meta/ and an org chart in venture.json; without it, the flat layout.
+const layout = flag("layout") ?? "flat";
+if (!["flat", "structured"].includes(layout)) { console.error(`unknown layout ${layout}: flat or structured`); process.exit(2); }
+const structured = layout === "structured";
+const vtype = typeId ? JSON.parse(readFileSync(join(here, "venture-types.json"), "utf8")).types.find((t) => t.id === typeId) : null;
+if (typeId && !vtype) { console.error(`unknown venture type ${typeId}: see node schema/venture-type.mjs list`); process.exit(2); }
 const [dir, id] = args;
 if (!dir || !id) { console.error("usage: node schema/init-venture.mjs <dir> <id> [--phase discovery] [--parent <id>] [--legal-form llc]"); process.exit(2); }
 if (!layers[phase]) { console.error(`unknown phase ${phase}: one of ${Object.keys(layers).join(", ")}`); process.exit(2); }
 if (existsSync(dir) && readdirSync(dir).length) { console.error(`${dir} already exists and is not empty: init creates new ventures only, and never writes into an existing project`); process.exit(1); }
 
 const ALL = ["purpose", "knowledge", "operations", "evidence", "governance", "interface"];
-const on = only !== null ? only.split(",").filter(Boolean) : [...layers[phase], ...(legalForm && legalForm !== "none" ? formalized : [])];
+const on = only !== null ? only.split(",").filter(Boolean) : [...new Set([...layers[phase], ...(vtype?.layers ?? []), ...(legalForm && legalForm !== "none" ? formalized : [])])];
 const unknown = on.filter((l) => !ALL.includes(l));
 if (unknown.length) { console.error(`unknown layers: ${unknown.join(", ")}; one of ${ALL.join(", ")}`); process.exit(2); }
 mkdirSync(dir, { recursive: true });
-const venture = { id, name: id, parent: parent ?? null, phase };
-if (legalForm) venture.form = { legal_form: legalForm };
+const venture = { id, name: id, ...(vtype ? { type: vtype.id } : {}), parent: parent ?? null, phase };
+if (legalForm || vtype?.funding) venture.form = { ...(legalForm ? { legal_form: legalForm } : {}), ...(vtype?.funding ? { funding: vtype.funding } : {}) };
 if (phase !== "discovery") venture.core = { promise: "", promised_to: "", must_not: "", competence: "" };
-Object.assign(venture, { owner: "self", status: "active", profile: "profile.md", layers: {} });
-for (const layer of ALL) {
+Object.assign(venture, { owner: "self", status: "active", profile: structured ? "README.md" : "profile.md", layers: {} });
+// The package folders (EE-070); a typed venture gets its type's packages.
+const packageDirs = vtype ? vtype.packages : ["foundation", "validation", "product", "marketing", "finance", "people", "customers", "investors", "money"];
+if (structured) {
+  // venture.json first, so every path below resolves into knowledge/ and meta/. The org chart starts flat:
+  // one function per package, owned by no one until create-venture or the founder names the owner.
+  venture.layout = "structured";
+  venture.functions = Object.fromEntries(packageDirs.map((p) => [p, { owner: null }]));
+  for (const layer of ALL) venture.layers[layer] = on.includes(layer) ? { location: "knowledge/" } : false;
+  writeFileSync(join(dir, "venture.json"), JSON.stringify(venture, null, 2) + "\n");
+  for (const sub of ["knowledge", "meta"]) mkdirSync(ventureFile(dir, sub), { recursive: true });
+}
+for (const layer of structured ? [] : ALL) {
   if (!on.includes(layer)) { if (only !== null || !["governance", "interface"].includes(layer)) venture.layers[layer] = false; continue; }
-  mkdirSync(join(dir, layer), { recursive: true });
+  mkdirSync(ventureFile(dir, layer), { recursive: true });
   writeFileSync(join(dir, layer, "README.md"), `# ${layer}\n\n${readme[layer]}\n`);
   venture.layers[layer] = { location: `${layer}/` };
 }
-for (const sub of ["products", "accounts"]) { mkdirSync(join(dir, sub), { recursive: true }); writeFileSync(join(dir, sub, ".gitkeep"), ""); }
+if (!structured) for (const sub of ["products", "accounts"]) { mkdirSync(ventureFile(dir, sub), { recursive: true }); writeFileSync(join(dir, sub, ".gitkeep"), ""); }
 // The package folder layout (EE-070). Old layer folders above stay for one release.
-for (const sub of ["raw/dump", "raw/sources", "ideas", "foundation", "validation", "product", "marketing", "finance", "people", "customers", "investors", "money", "decisions", "evidence", "public", "_private", "_drafts", ".release"]) {
-  mkdirSync(join(dir, sub), { recursive: true });
+// A typed venture gets its type's packages; the rest stay out until need-now suggests them.
+for (const sub of ["raw/dump", "raw/sources", "ideas", ...packageDirs, "decisions", "evidence", ...(structured ? [] : ["public"]), "_private", "_drafts", ".release"]) {
+  mkdirSync(ventureFile(dir, sub), { recursive: true });
 }
-mkdirSync(join(dir, "pillars"), { recursive: true });
-for (const [name, what] of Object.entries(pillars.stubs)) {
-  const guide = relative(join(dir, "pillars"), join(repo, pillars.guides, `${name}.md`));
-  writeFileSync(join(dir, "pillars", `${name}.md`), `# ${name[0].toUpperCase() + name.slice(1)} pillar\n\n${what}\n\nGuide: [${name} pillar](${guide})\n`);
+if (!structured) mkdirSync(join(ventureFile(dir, "pillars")), { recursive: true });
+for (const [name, what] of Object.entries(structured ? {} : pillars.stubs)) {
+  const guide = relative(join(ventureFile(dir, "pillars")), join(repo, pillars.guides, `${name}.md`));
+  writeFileSync(join(ventureFile(dir, "pillars"), `${name}.md`), `# ${name[0].toUpperCase() + name.slice(1)} pillar\n\n${what}\n\nGuide: [${name} pillar](${guide})\n`);
 }
-writeFileSync(join(dir, "profile.md"), `# ${id}\n\nWhat this venture is, in a few sentences. Its machine fields are in venture.json (EE-011).\n\n## Changelog\n`);
-writeFileSync(join(dir, "venture.json"), JSON.stringify(venture, null, 2) + "\n");
+writeFileSync(join(ventureFile(dir, "profile.md")), `# ${id}\n\nWhat this venture is, in a few sentences. Its machine fields are in venture.json (EE-011).\n\n## Changelog\n`);
+if (!structured) writeFileSync(join(dir, "venture.json"), JSON.stringify(venture, null, 2) + "\n");
 // The venture's root layout (EE-072, I-4): every route's layout chain starts here. Lines shaped
 // "key: value" are instructions the router hands an agent with the layout.
 writeFileSync(join(dir, "AGENTS.md"), `# AGENTS.md: ${id}
@@ -87,12 +112,35 @@ const productFoundation = [
 ];
 // The team question (EE-060): asked in Discovery, failing open, so validation never waits on it. A
 // founding team, or a founder looking for one, gets the founder-agreement kit beside validation.
-mkdirSync(join(dir, "decisions"), { recursive: true });
-writeFileSync(join(dir, "decisions/venture.team.decision.json"), JSON.stringify({ id: "founding-team", question: "Who is founding this venture: you alone, you with cofounders, or you looking for cofounders?",
+mkdirSync(join(ventureFile(dir, "decisions")), { recursive: true });
+writeFileSync(join(ventureFile(dir, "decisions/venture.team.decision.json")), JSON.stringify({ id: "founding-team", question: "Who is founding this venture: you alone, you with cofounders, or you looking for cofounders?",
   decides: { record: "founder-agreement", path: "governance/founder-agreement.json" }, layer: "governance", boundary: "fail-open", needed_in: phase, status: "open",
   options: ["Solo: I am founding it alone", "Cofounders: we are founding it together", "Looking: I want cofounders"],
   unlocks: [{ activity: "Draft the founder agreement with the founding-agreement kit", routes: ["governance/founder-agreement"] }], provenance: framework }, null, 2) + "\n");
-mkdirSync(join(dir, "products/decisions"), { recursive: true });
-for (const d of productFoundation) writeFileSync(join(dir, "products/decisions", `product.${d.id.replace(/^product-/, "")}.decision.json`),
+// A fund's foundation (EE-082): the thesis first, then the terms it raises under, then the first close.
+const fundFoundation = [
+  { id: "fund-thesis", question: "What does the fund invest in, and why does it win: rounds, sectors, geographies, check size and its edge?", decides: { record: "fund-thesis", path: "fund/thesis.json" },
+    unlocks: [{ activity: "Screen deals against the thesis", routes: ["deals/*"] }] },
+  { id: "fund-terms", parent: "fund-thesis", question: "What are the fund's terms: target size, vintage, structure, management fee, carry and term?", decides: { record: "fund-terms", path: "fund/terms.json" },
+    unlocks: [{ activity: "Raise from limited partners", routes: ["investors/*"] }] },
+  { id: "first-close", parent: "fund-terms", question: "When is the first close, and how much must be committed to hold it?", decides: { record: "fund-terms", path: "fund/terms.json" },
+    unlocks: [{ activity: "Make the first investment", routes: ["portfolio/*"] }] },
+];
+const decisionSet = vtype?.decisions ?? "product-foundation";
+if (decisionSet === "fund-foundation") {
+  mkdirSync(join(ventureFile(dir, "fund/decisions")), { recursive: true });
+  for (const d of fundFoundation) writeFileSync(join(ventureFile(dir, "fund/decisions"), `${d.id === "first-close" ? "terms.first-close" : d.id.replace(/^fund-/, "")}.decision.json`),
+    JSON.stringify({ ...d, layer: "purpose", boundary: "fail-closed", needed_in: phase, status: "open", provenance: framework }, null, 2) + "\n");
+}
+// The product questions sit beside the products: product/ in the structured layout, products/ in the flat one.
+const productDecisions = structured ? "product/decisions" : "products/decisions";
+if (decisionSet === "product-foundation") mkdirSync(join(ventureFile(dir, productDecisions)), { recursive: true });
+if (decisionSet === "product-foundation") for (const d of productFoundation) writeFileSync(join(ventureFile(dir, productDecisions), `product.${d.id.replace(/^product-/, "")}.decision.json`),
   JSON.stringify({ ...d, layer: "purpose", boundary: "fail-closed", needed_in: phase, status: "open", provenance: framework }, null, 2) + "\n");
-console.log(`created venture ${id} (${phase}) in ${dir} with ${on.join(", ") || "no layers"}, products/, accounts/ and the three pillars.${venture.core ? " Fill in the core product before ranking products." : ""}`);
+// The type's functions are imported like any department (EE-047): listed in venture.json, with their folders.
+// In the structured layout the org chart is venture.json's functions; the flat layout imports departments.
+if (vtype && !structured) for (const d of vtype.departments) {
+  const r = spawnSync("node", [join(here, "add-department.mjs"), dir, d], { encoding: "utf8" });
+  if (r.status !== 0) { console.error((r.stderr || r.stdout).trim()); process.exit(1); }
+}
+console.log(`created ${vtype ? `${vtype.label.toLowerCase()} ` : ""}venture ${id} (${phase}) in ${dir} with ${on.join(", ") || "no layers"}, products/, accounts/ and the three pillars.${venture.core ? " Fill in the core product before ranking products." : ""}`);

package/schema/judgment.schema.json

@@ -0,0 +1,38 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "judgment.schema.json",
+  "title": "Judgment",
+  "description": "The output of one model step (\"use model\", EE-073), at <venture>/knowledge/judgments/<id>.json: the package and step that asked, the item it was asked about, the paths the model was given, its typed answer and confidence, the computed values it had to keep, and what code did with it. A judgment is the agent's until a person confirms it; the records it read stay their authors'. Written by schema/model-steps.mjs through the router.",
+  "type": "object",
+  "required": ["id", "package", "step", "kind", "question", "reads", "outcome", "answer", "by"],
+  "additionalProperties": false,
+  "properties": {
+    "id": { "type": "string", "pattern": "^[a-z0-9][a-z0-9-]*$", "description": "<package>-<step>-<item>, or <package>-<step> for a step asked once" },
+    "package": { "type": "string", "description": "The package (or kit) that declares the step" },
+    "step": { "type": "string", "description": "The step id in the package's use_model" },
+    "kind": { "enum": ["classify", "noul", "choice", "score", "draft"], "description": "classify a fragment, judge fit (noul: yes, no or unknown), choose among options, rate on a scale, or draft prose. Only a draft is model-only" },
+    "item": { "type": ["string", "null"], "description": "The record id the step was asked about, for a step asked for each item of a collection" },
+    "question": { "type": "string", "description": "The question as asked, its {paths} pointing into the state" },
+    "reads": { "type": "array", "items": { "type": "string" }, "description": "The venture-relative files and the field paths the model was given, and nothing else" },
+    "outcome": { "enum": ["answer", "overruled", "uncertain"], "description": "answer: typed, at or above threshold, and every check passed. overruled: a code check disagreed and the code's value stands. uncertain: below threshold, malformed or unanswered, and routed to a person" },
+    "answer": { "description": "The typed answer (the code's value when overruled; null when uncertain)" },
+    "confidence": { "type": ["number", "null"], "minimum": 0, "maximum": 1 },
+    "threshold": { "type": ["number", "null"], "minimum": 0, "maximum": 1 },
+    "why": { "type": "string", "description": "Why the outcome is what it is" },
+    "kept": { "type": "object", "description": "Computed values the answer had to carry unchanged, and they did" },
+    "overruled": { "type": "object", "additionalProperties": false, "properties": { "judgment": {}, "code": {}, "check": { "type": "string" } } },
+    "decision": { "type": "string", "description": "The open decision a person answers when the judgment is uncertain" },
+    "by": {
+      "type": "object",
+      "required": ["kind"],
+      "additionalProperties": false,
+      "properties": {
+        "kind": { "enum": ["model", "person"] },
+        "model": { "type": "string" },
+        "name": { "type": "string" }
+      }
+    },
+    "state_sha256": { "type": "string", "pattern": "^[0-9a-f]{64}$", "description": "Hash of the question and the state the model was given; a later run reuses the judgment while it is unchanged" },
+    "asked_at": { "type": "string", "format": "date-time" }
+  }
+}

package/schema/kit.schema.json

@@ -0,0 +1,47 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "kit.schema.json",
+  "title": "Kit",
+  "description": "A Mentura kit (EE-071): an enhanced package, at platform/kits/<name>/kit.json. It extends one Naive package (automations, agent workflows, skills, connectors on top of it) or one framework command (an agent-run upgrade), and never replaces it. The framework reads this manifest as data and runs the kit's entry as its own process; it never imports platform code (schema/kits.mjs). Automations are triggers a venture turns on by listing the kit in naive.config.json kits; each runs only once the package it needs is complete (schema/triggers.mjs).",
+  "type": "object",
+  "required": ["name", "title", "purpose", "extends", "use_model", "status"],
+  "additionalProperties": false,
+  "properties": {
+    "name": { "type": "string", "pattern": "^[a-z][a-z0-9-]*$" },
+    "title": { "type": "string" },
+    "purpose": { "type": "string" },
+    "extends": {
+      "type": "object",
+      "additionalProperties": false,
+      "minProperties": 1,
+      "maxProperties": 1,
+      "properties": {
+        "package": { "type": "string", "description": "The Naive package it enhances (packages/<name>/package.json)" },
+        "command": { "type": "string", "description": "The framework command it extends, such as \"upgrade --agent\"" }
+      }
+    },
+    "entry": { "type": "string", "description": "The kit's program, relative to its folder, run as node <entry> <venture dir>" },
+    "agent": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["command"],
+      "properties": {
+        "command": { "type": "array", "items": { "type": "string" }, "description": "The agent it runs by default; MENTURA_AGENT_CMD replaces it" },
+        "env": { "type": "array", "items": { "type": "string", "pattern": "^[A-Z][A-Z0-9_]*$" }, "description": "Environment variables it reads, by name" }
+      }
+    },
+    "automations": {
+      "type": "array",
+      "items": { "$ref": "trigger.schema.json" },
+      "description": "Triggers the kit brings; each names the package it needs (needs)"
+    },
+    "use_model": {
+      "type": "array",
+      "items": { "type": "string" },
+      "description": "The steps that call a model (\"use model\", S-9); empty when none does"
+    },
+    "checks": { "type": "array", "items": { "type": "string" }, "description": "What decides whether the kit's work lands; always framework code" },
+    "status": { "enum": ["built", "experimental"] },
+    "note": { "type": "string" }
+  }
+}