naive-framework 0.0.0-stage → 0.2.0

package/schema/icp.schema.json

@@ -0,0 +1,136 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "icp.schema.json",
+  "title": "Ideal customer profile",
+  "description": "Who the venture serves (EE-051), at <venture>/purpose/icp.json: the 'who' foundation statement. One or more profiles, one primary, each specific enough to go and find ten of them, with what they are trying to do, what gets in the way and who is out of scope. Gated like the telos: an agent's write is a draft the founder accepts.",
+  "type": "object",
+  "required": [
+    "venture",
+    "profiles"
+  ],
+  "additionalProperties": false,
+  "properties": {
+    "venture": {
+      "type": "string"
+    },
+    "updated": {
+      "type": "string",
+      "format": "date"
+    },
+    "decision": {
+      "type": "string",
+      "description": "The decision that set it, such as EE-045"
+    },
+    "profiles": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "required": [
+          "id",
+          "who"
+        ],
+        "additionalProperties": false,
+        "properties": {
+          "id": {
+            "type": "string",
+            "pattern": "^[a-z0-9-]+$"
+          },
+          "who": {
+            "type": "string",
+            "description": "Who they are, specifically enough to find ten of them"
+          },
+          "short": {
+            "type": "string",
+            "description": "One line naming who they are; the venture's promised-to statement shows it (EE-052)"
+          },
+          "primary": {
+            "type": "boolean",
+            "description": "Exactly one profile is primary"
+          },
+          "customer": {
+            "enum": [
+              "b2b",
+              "b2c",
+              "b2g"
+            ]
+          },
+          "phases": {
+            "type": "array",
+            "items": {
+              "enum": [
+                "discovery",
+                "validation",
+                "beachhead",
+                "scale",
+                "platform"
+              ]
+            },
+            "description": "The phases of their own venture they are in, when they are founders"
+          },
+          "traits": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "description": "What must be true of them"
+          },
+          "jobs": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "description": "What they are trying to get done (jobs to be done)"
+          },
+          "problem_forms": {
+            "type": "array",
+            "items": {
+              "type": "string",
+              "pattern": "^[a-z0-9-]+$"
+            },
+            "description": "Ids of the problem record's forms they have"
+          },
+          "where_to_find": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "description": "Where to reach them: communities, channels, events"
+          },
+          "not": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "description": "Who is out of scope, and why"
+          },
+          "buying_roles": {
+            "type": "array",
+            "items": {
+              "enum": [
+                "initiator",
+                "user",
+                "influencer",
+                "decider",
+                "buyer",
+                "gatekeeper"
+              ]
+            },
+            "description": "The parts this profile plays in a purchase (the buying center: Webster and Wind 1972; initiator added by Bonoma 1982). One person may hold several; a solo founder or a consumer usually holds them all."
+          },
+          "reached_through": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "description": "Other profiles (ids) through whom the venture reaches this one, such as a channel partner in a B2B2C venture (EE-064)"
+          },
+          "customer_type": {
+            "type": "string",
+            "description": "The customer type from the marketing matrix (operations/marketing/site/matrix.json customer_types), when the founder sets it; otherwise it is judged from who (EE-063)"
+          }
+        }
+      }
+    }
+  }
+}

package/schema/idea-graph.schema.json

@@ -0,0 +1,61 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "idea-graph.schema.json",
+  "title": "Idea graph",
+  "description": "The structured form of a founder's idea map (EE-060): a Merkle DAG. Each idea's hash covers its text and the hashes of the ideas it builds on, so a change upstream changes every hash downstream. Written by purpose/frameworks/idea-map/graph.mjs; it holds no decisions.",
+  "type": "object",
+  "required": ["version", "venture", "phase", "root", "judged_by", "nodes", "edges", "lanes", "next"],
+  "properties": {
+    "version": { "type": "string" },
+    "venture": { "type": "string" },
+    "phase": { "enum": ["discovery", "validation", "beachhead", "scale", "platform"] },
+    "created": { "type": "string" },
+    "source": { "type": "string", "description": "The idea map it was built from, with that file's hash" },
+    "root": { "type": "string", "description": "Hash over the hashes of the ideas nothing builds on: one value for the whole graph" },
+    "judged_by": { "enum": ["jev", "convention"], "description": "Who judged the dependencies: Jev's typed answers, or Naive's convention of which records build on which" },
+    "weights": { "type": "object", "additionalProperties": { "type": "number" } },
+    "nodes": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["id", "hash", "text", "depth", "builds_on", "signal", "lane"],
+        "properties": {
+          "id": { "type": "string", "pattern": "^i-\\d+$" },
+          "hash": { "type": "string", "pattern": "^[0-9a-f]{16}$" },
+          "text": { "type": "string", "description": "The founder's words, unchanged" },
+          "section": { "type": "string" },
+          "pillar": { "type": ["string", "null"] },
+          "departments": { "type": "array", "items": { "type": "string" } },
+          "records": { "type": "array", "items": { "type": "string" } },
+          "exists": { "type": "boolean" },
+          "depth": { "type": "integer", "minimum": 0, "description": "Longest chain of ideas before it: its column, left to right" },
+          "builds_on": { "type": "array", "items": { "type": "string" } },
+          "signal": { "type": "number", "minimum": 0, "maximum": 1 },
+          "parts": { "type": "object", "additionalProperties": { "type": "number" } },
+          "lane": { "type": "string" }
+        }
+      }
+    },
+    "edges": {
+      "type": "array",
+      "items": { "type": "object", "required": ["from", "to", "p"], "properties": { "from": { "type": "string" }, "to": { "type": "string" }, "p": { "type": "number" }, "by": { "type": "string" } } }
+    },
+    "dropped": { "type": "array", "description": "Dependencies left out because they would have closed a cycle" },
+    "lanes": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["id", "mode", "ideas"],
+        "properties": {
+          "id": { "type": "string" },
+          "mode": { "enum": ["sync", "async"], "description": "sync: its ideas build on each other and move in order; async: it moves on its own, beside the other lanes" },
+          "ideas": { "type": "array", "items": { "type": "string" } },
+          "department": { "type": ["string", "null"] },
+          "signal": { "type": "number" },
+          "why": { "type": "string" }
+        }
+      }
+    },
+    "next": { "type": "array", "items": { "type": "string" }, "description": "The highest-signal ideas that build on nothing: what to develop next" }
+  }
+}

package/schema/init-venture.mjs

@@ -0,0 +1,128 @@
+// Creates an empty venture: its folder, one folder per starting layer, products/,
+// accounts/, the three pillars as stubs pointing to their guides (EE-010), a venture profile and a venture.json to fill in
+// (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.
+//
+// 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";
+
+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"), typeId = flag("type");
+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) : [...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, ...(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) {
+  if (!on.includes(layer)) { if (only !== null || !["governance", "interface"].includes(layer)) venture.layers[layer] = false; continue; }
+  mkdirSync(join(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"), ""); }
+// The package folder layout (EE-070). Old layer folders above stay for one release.
+// A typed venture gets its type's packages; the rest stay out until need-now suggests them.
+const packageDirs = vtype ? vtype.packages : ["foundation", "validation", "product", "marketing", "finance", "people", "customers", "investors", "money"];
+for (const sub of ["raw/dump", "raw/sources", "ideas", ...packageDirs, "decisions", "evidence", "public", "_private", "_drafts", ".release"]) {
+  mkdirSync(join(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`);
+}
+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");
+// 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}
+
+The map of this venture for agents. Read it, then a route's layout, before writing anything here.
+
+## How to work here
+
+- List the routes with \`mentura routes\`. Read a route's \`layout\` and \`template\` before you write to it.
+- Write through the router (the CLI or the MCP server), not by editing files. Every write is checked against its schema and recorded in provenance.jsonl.
+- A write that fails closed comes back as a draft in \`_drafts/\`. A person accepts it with \`mentura accept\`.
+- Never read or send anything under \`_private/\` to a model.
+- A deeper AGENTS.md (for example \`marketing/AGENTS.md\`) adds to this one for the routes under it; the nearer one wins.
+
+## Instructions
+
+phase: ${venture.phase}
+voice: plain words, in the founder's own terms
+private: _private/
+`);
+// The product foundation (EE-059): Naive's own questions about products, asked first and failing
+// closed. Does a product exist already, what is the core product, which product is the flagship.
+// Each waits on the one before it; agents may not write product cards until the first is answered.
+const framework = { drafted_by: { kind: "framework", id: "naive" } };
+const productFoundation = [
+  { id: "product-exists", question: "Does a product already exist (in use, for sale, a prototype or a pilot), or is the venture still an idea?", decides: { record: "product", path: "products/" }, statement: "products",
+    options: ["Yes: one or more products exist", "Partly: a prototype or pilot exists", "No: it is still an idea"],
+    unlocks: [{ activity: "Write product cards for what exists or is planned", routes: ["purpose/product/*"] }] },
+  { id: "core-product", parent: "product-exists", question: "What is the core product: what anyone can claim from this venture, who it is promised to, what it must never deliver, and the competence that makes it deliverable?", decides: { record: "venture", path: "venture.json" },
+    unlocks: [{ activity: "Judge the products against the core (Product Anatomy)", routes: ["purpose/anatomy-input/*", "purpose/anatomy-answers"] }] },
+  { id: "flagship", parent: "core-product", question: "Which product is the flagship now: the one that best delivers the core promise?", decides: { record: "product", path: "products/" },
+    unlocks: [{ activity: "Plan how to validate the flagship", routes: ["purpose/validation/solution"] }] },
+];
+// 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?",
+  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");
+// 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(dir, "fund/decisions"), { recursive: true });
+  for (const d of fundFoundation) writeFileSync(join(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");
+}
+if (decisionSet === "product-foundation") mkdirSync(join(dir, "products/decisions"), { recursive: true });
+if (decisionSet === "product-foundation") for (const d of productFoundation) writeFileSync(join(dir, "products/decisions", `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");
+// The type's functions are imported like any department (EE-047): listed in venture.json, with their folders.
+if (vtype) 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/integration.schema.json

@@ -0,0 +1,143 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "integration.schema.json",
+  "title": "Layer tooling integration",
+  "description": "One tool or service a layer can use. Each layer lists its integrations in <layer>/tooling/integrations.json. Credentials are named, never stored. Entries under interface/ are interfaces, not integrations: they must reach at least three of the five other layers (EE-038) (schema/check-integrations.mjs). Knowledge integrations with a connector are the connector registry (EE-037): a venture's knowledge/sources.json names them by id.",
+  "type": "object",
+  "required": [
+    "id",
+    "name",
+    "layer",
+    "role",
+    "interfaces",
+    "status"
+  ],
+  "properties": {
+    "id": {
+      "type": "string",
+      "pattern": "^[a-z0-9-]+$"
+    },
+    "name": {
+      "type": "string"
+    },
+    "layer": {
+      "enum": [
+        "purpose",
+        "knowledge",
+        "operations",
+        "evidence",
+        "governance",
+        "interface"
+      ]
+    },
+    "role": {
+      "type": "string",
+      "description": "What the layer uses it for, in a few words"
+    },
+    "interfaces": {
+      "type": "array",
+      "items": {
+        "enum": [
+          "files",
+          "mcp",
+          "api",
+          "sdk",
+          "cli",
+          "webhook",
+          "app"
+        ]
+      },
+      "description": "How agents and code reach it"
+    },
+    "reach": {
+      "type": "array",
+      "uniqueItems": true,
+      "items": {
+        "enum": [
+          "purpose",
+          "knowledge",
+          "operations",
+          "evidence",
+          "governance"
+        ]
+      },
+      "description": "Interface layer only: the other layers a person can work in through it, in one session. At least three of the five."
+    },
+    "interface_kind": {
+      "enum": [
+        "agent-harness",
+        "custom"
+      ],
+      "description": "Interface layer only: an agent harness (built around an AI agent's loop, tools and files) or a custom interface built for the system or a venture."
+    },
+    "status": {
+      "enum": [
+        "in-use",
+        "candidate",
+        "rejected"
+      ]
+    },
+    "reason": {
+      "type": "string",
+      "description": "Why it is in use, a candidate, or rejected"
+    },
+    "credentials": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "description": "Environment variable names only"
+    },
+    "adapter": {
+      "type": "string",
+      "description": "Path to the skill, MCP config or script that wires it in, when one exists"
+    },
+    "links": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "connector": {
+      "type": "object",
+      "required": [
+        "module",
+        "writes"
+      ],
+      "additionalProperties": false,
+      "description": "Knowledge layer only: the module that implements the connector contract (knowledge/connectors/contract.mjs) for this integration, so a venture's knowledge/sources.json can keep records in it (EE-037)",
+      "properties": {
+        "module": {
+          "type": "string",
+          "pattern": "^(knowledge|platform)/connectors/[a-z0-9-]+\\.mjs$",
+          "description": "Path from the repository root; it exports connect(options). A connector that works offline and names no vendor is framework (knowledge/connectors/); any other is platform (platform/connectors/), EE-041"
+        },
+        "writes": {
+          "type": "array",
+          "minItems": 1,
+          "uniqueItems": true,
+          "items": {
+            "enum": [
+              "direct",
+              "pull-request",
+              "none"
+            ]
+          },
+          "description": "The write modes it supports; the first is its default"
+        },
+        "options": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "The source options it takes, besides id and writes"
+        },
+        "eval": {
+          "type": "string",
+          "description": "The command that runs the contract evals against it"
+        }
+      }
+    }
+  },
+  "additionalProperties": false
+}

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" }
+  }
+}

package/schema/kits.mjs

@@ -0,0 +1,24 @@
+// Mentura kits, as the framework sees them (EE-071): data only. A kit lives at
+// platform/kits/<name>/kit.json and extends one Naive package or one framework command. The framework
+// reads a kit's manifest by path and runs its entry as a separate process, never importing platform
+// code (schema/check-boundary.mjs), the way a Next.js build loads a deployment adapter it was pointed
+// at. A copy of the framework without platform/ has no kits, and nothing here fails because of it.
+
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const repo = new URL("..", import.meta.url).pathname;
+export const KITS = "platform/kits";
+
+/** Every installed kit: { name, path, dir, ...kit.json }. */
+export function kits(root = process.env.NAIVE_KITS ?? join(repo, KITS)) {
+  if (!existsSync(root)) return [];
+  return readdirSync(root, { withFileTypes: true }).filter((e) => e.isDirectory() && existsSync(join(root, e.name, "kit.json")))
+    .map((e) => ({ ...JSON.parse(readFileSync(join(root, e.name, "kit.json"), "utf8")), dir: join(root, e.name), path: join(root, e.name, "kit.json") }));
+}
+
+/** The kit that extends a framework command (such as "upgrade --agent"), or null. */
+export const kitFor = (command) => kits().find((k) => k.extends?.command === command) ?? null;
+
+/** One kit by name, or null. */
+export const kit = (name) => kits().find((k) => k.name === name) ?? null;