naive-framework 0.1.0 → 0.3.0

package/interface/dev/setup.mjs

@@ -0,0 +1,84 @@
+// The setup page (EE-083): what `naive dev` serves at /setup, the way next dev serves a first page. It
+// walks a founder through establishing the venture's structure, in order: the venture and its people,
+// where each function keeps its truth, the strategic foundation and the first decisions (the decision
+// docket), and a goal for the discovery phase. Every answer is written as the code would write it:
+// a decision a person approves (schema/decisions.mjs), or knowledge/sources.json through the router, with
+// provenance. When the docket's first decisions are settled, the page says the structure is established
+// and what comes next.
+//
+//   handle(req, res, dir) -> true when it answered a /setup request
+
+import { decide, point, state } from "../../schema/setup.mjs";
+
+const json = (res, code, body) => { res.writeHead(code, { "content-type": "application/json" }); res.end(JSON.stringify(body)); };
+const body = (req) => new Promise((ok) => { let b = ""; req.on("data", (c) => (b += c)); req.on("end", () => { try { ok(JSON.parse(b || "{}")); } catch { ok({}); } }); });
+const GOAL = "discovery-goal";
+
+export async function handle(req, res, dir) {
+  const u = new URL(req.url, "http://x");
+  if (!u.pathname.startsWith("/setup")) return false;
+  if (u.pathname === "/setup" || u.pathname === "/setup/") { res.writeHead(200, { "content-type": "text/html; charset=utf-8" }); res.end(PAGE); return true; }
+  if (u.pathname === "/setup/state") { json(res, 200, await state(dir)); return true; }
+  if (req.method === "POST" && u.pathname === "/setup/decide") { const r = await decide(dir, await body(req)); json(res, r.ok ? 200 : 400, r); return true; }
+  if (req.method === "POST" && u.pathname === "/setup/point") { const r = await point(dir, await body(req)); json(res, r.ok ? 200 : 400, r); return true; }
+  json(res, 404, { error: "no such setup route" });
+  return true;
+}
+
+const PAGE = `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Set up your venture</title>
+<style>
+:root { --bg:#f6f7f4; --panel:#fff; --fg:#1d2320; --muted:#5d675f; --line:#d9ded8; --accent:#2f6b4f; --accent-soft:#e3efe8; --warn:#8a5a00; --warn-soft:#f6ecd8;
+  --body: "Source Sans 3", system-ui, -apple-system, "Segoe UI", sans-serif; --mono: ui-monospace, "SF Mono", Menlo, monospace; color-scheme: light; }
+@media (prefers-color-scheme: dark) { :root { --bg:#121614; --panel:#1a201d; --fg:#e4e9e5; --muted:#9aa59d; --line:#2b332e; --accent:#86c4a3; --accent-soft:#1d2b24; --warn:#e3b25c; --warn-soft:#2c2414; color-scheme: dark; } }
+* { box-sizing: border-box } body { margin:0; background:var(--bg); color:var(--fg); font:16px/1.55 var(--body); }
+.wrap { max-width: 860px; margin: 0 auto; padding: 32px max(16px, env(safe-area-inset-left)) 80px; display: grid; gap: 28px; }
+header { display:grid; gap:6px } h1 { margin:0; font-size:1.9rem; letter-spacing:-.01em } h2 { margin:0 0 4px; font-size:1.2rem }
+.muted { color: var(--muted) } .mono { font-family: var(--mono); font-size: .88em }
+.progress { display:flex; gap:6px; flex-wrap:wrap } .step { font:600 .78rem/1 var(--mono); padding:7px 10px; border-radius:999px; border:1px solid var(--line); color:var(--muted) }
+.step.ok { background: var(--accent-soft); color: var(--accent); border-color: transparent }
+section { background: var(--panel); border:1px solid var(--line); border-radius:10px; padding:20px; display:grid; gap:14px }
+table { width:100%; border-collapse: collapse; font-size:.95rem } td, th { text-align:left; padding:8px 6px; border-bottom:1px solid var(--line); vertical-align: top } th { font: 600 .74rem/1.2 var(--mono); text-transform: uppercase; letter-spacing:.05em; color: var(--muted) }
+.pill { display:inline-block; font:600 .72rem/1 var(--mono); padding:4px 7px; border-radius:999px; background: var(--accent-soft); color: var(--accent); margin: 0 4px 4px 0 } .pill.pointed { background: var(--line); color: var(--fg) } .pill.none { background: var(--warn-soft); color: var(--warn) }
+.card { border:1px solid var(--line); border-radius:8px; padding:14px; display:grid; gap:10px } .card.done { opacity:.75 }
+.card .q { font-weight:600 } textarea, input, select { font: inherit; color: inherit; background: var(--bg); border:1px solid var(--line); border-radius:6px; padding:8px; width:100% }
+.row { display:flex; gap:8px; flex-wrap:wrap; align-items:center } .row > * { flex: 1 1 140px }
+button { font: 600 .92rem var(--body); background: var(--accent); color: var(--bg); border: 0; border-radius: 6px; padding: 9px 14px; cursor: pointer; flex: 0 0 auto }
+button.ghost { background: transparent; color: var(--accent); border:1px solid var(--accent) } button:focus-visible, textarea:focus-visible, input:focus-visible, select:focus-visible { outline: 2px solid var(--accent); outline-offset: 2px }
+.err { color: var(--warn); font-size: .9rem } .celebrate { text-align:center; padding: 32px 20px; display:grid; gap:10px; background: var(--accent-soft); border-color: transparent }
+.celebrate .big { font-size: 2.2rem; font-weight: 700; color: var(--accent) } ol { margin:0; padding-left: 1.2em; display:grid; gap:6px; text-align:left }
+@media (prefers-reduced-motion: no-preference) { .celebrate { animation: pop .5s ease-out } @keyframes pop { from { transform: scale(.97); opacity:.4 } to { transform: none; opacity:1 } } }
+</style></head><body><div class="wrap" id="app"><p class="muted">Loading your venture…</p></div>
+<script>
+const $ = (s) => document.querySelector(s);
+const esc = (s) => String(s ?? "").replace(/[&<>"]/g, (c) => ({ "&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;" })[c]);
+const post = (u, b) => fetch(u, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify(b) }).then((r) => r.json());
+let S = null;
+async function load() { S = await fetch("/setup/state").then((r) => r.json()); render(); }
+function render() {
+  const v = S.venture, st = S.steps;
+  const label = (k, t) => '<span class="step ' + (st[k] ? "ok" : "") + '">' + (st[k] ? "✓ " : "") + t + "</span>";
+  const people = S.people ? '<table><tr><th>Person</th><th>Role</th><th>Hats</th></tr>' + S.people.people.map((p) => "<tr><td>" + esc(p.name) + "</td><td class=mono>" + esc(p.role) + "</td><td>" + (p.hats.map((h) => '<span class="pill pointed">' + esc(h) + "</span>").join("") || '<span class="muted">none</span>') + "</td></tr>").join("") + "</table>" : '<p class="err">No people/people.json yet: create the venture with create-venture.</p>';
+  const fns = [...new Set([...Object.keys(S.catalog.functions).filter((f) => f === "legal" || (S.people?.people ?? []).some((p) => p.hats.includes(f))), ...Object.keys(S.functions)])];
+  const truth = '<table><tr><th>Function</th><th>Source of truth</th></tr>' + fns.map((f) => { const x = S.functions[f]; const sys = x?.systems?.length ? x.systems.map((s) => '<span class="pill ' + (s.status === "connected" ? "" : "pointed") + '">' + esc(S.catalog.systems[s.system]?.label ?? s.system) + (s.address ? " · " + esc(s.address) : "") + " · " + s.status + (s.fixture ? " (fixture)" : "") + "</span>").join("") : '<span class="pill none">none yet</span>' + (x?.note ? ' <span class="muted">' + esc(x.note) + "</span>" : ""); return "<tr><td>" + esc(f === "legal" ? "legal documents" : f) + "</td><td>" + sys + "</td></tr>"; }).join("") + "</table>"
+    + '<div class="row"><select id="fn">' + fns.map((f) => "<option>" + f + "</option>").join("") + '</select><select id="sys"></select><input id="addr" placeholder="address, such as acme/web"><button id="point">Point</button></div><div class="err" id="perr"></div>';
+  const cards = S.docket.map((d) => '<div class="card ' + (d.status === "decided" ? "done" : "") + '" data-id="' + esc(d.id) + '"><div class="q">' + esc(d.question) + "</div>" + (d.status === "decided" ? '<div>✓ <span class="muted">' + esc(d.answer) + "</span></div>" : (d.options.length ? '<div class="row">' + d.options.map((o) => '<button class="ghost opt">' + esc(o) + "</button>").join("") + "</div>" : "") + '<textarea rows="2" placeholder="In your own words"></textarea><div class="row"><button class="ans">Save</button><span class="err"></span></div>') + "</div>").join("");
+  const goal = S.goal?.status === "decided" ? '<p>✓ ' + esc(S.goal.answer) + "</p>" : '<textarea id="goal" rows="2" placeholder="For example: ten clinic owners confirm the scheduling problem in interviews by December"></textarea><div class="row"><button id="setgoal">Set the goal</button><span class="err" id="gerr"></span></div>';
+  const done = S.done ? '<section class="celebrate"><div class="big">Your venture is structured.</div><p>' + esc(v.name) + " has its people and their hats, a source of truth for its functions, a settled foundation, and a goal for discovery. Every decision from here routes through the docket.</p><ol><li>Run <span class=mono>npm run dev</span> and keep the board open: decisions waiting on you show there first.</li><li>Orient each next decision around the discovery goal; a sprint or campaign is a set of decisions toward it.</li><li>To operate the venture with your team and agents (tasks, documents, money and people in one workspace), connect it to Mentura.</li></ol>" + (S.later ? '<p class="muted">' + S.later + " more decisions come later, as the venture needs them.</p>" : "") + "</section>" : "";
+  $("#app").innerHTML = '<header><span class="muted mono">' + esc(v.type?.label ?? "venture") + " · " + esc(v.phase) + '</span><h1>Set up ' + esc(v.name) + '</h1><p class="muted">Establish the structure of your venture. Each answer is saved as you go.</p><div class="progress">' + label("people", "People and hats") + label("truth", "Sources of truth") + label("docket", "Foundation and first decisions " + S.counts.settled + "/" + S.counts.of) + label("goal", "Discovery goal") + "</div></header>" + done
+    + "<section><h2>1. People and hats</h2>" + people + "</section>"
+    + '<section><h2>2. Sources of truth</h2><p class="muted">Point Naive at where each function keeps its truth. Naive keeps pointers, never copies; Rho is read through its API.</p>' + truth + "</section>"
+    + '<section><h2>3. Foundation and first decisions</h2><p class="muted">The decision docket: what the venture must settle first, in order.</p>' + cards + "</section>"
+    + '<section><h2>4. A goal for discovery</h2><p class="muted">What must be true to leave discovery? Every decision after this one works toward it.</p>' + goal + "</section>";
+  const sysFor = () => { $("#sys").innerHTML = (S.catalog.functions[$("#fn").value] ?? []).map((s) => '<option value="' + s + '">' + esc(S.catalog.systems[s].label) + "</option>").join(""); $("#addr").placeholder = S.catalog.systems[$("#sys").value]?.address ?? "address"; };
+  $("#fn").onchange = sysFor; sysFor(); $("#sys").onchange = () => ($("#addr").placeholder = S.catalog.systems[$("#sys").value]?.address ?? "address");
+  $("#point").onclick = async () => { const r = await post("/setup/point", { fn: $("#fn").value, system: $("#sys").value, address: $("#addr").value.trim() || undefined }); if (!r.ok) $("#perr").textContent = r.error; else load(); };
+  document.querySelectorAll(".card").forEach((c) => {
+    const id = c.dataset.id, ta = c.querySelector("textarea");
+    c.querySelectorAll(".opt").forEach((b) => (b.onclick = () => { ta.value = b.textContent; }));
+    const save = c.querySelector(".ans"); if (save) save.onclick = async () => { const r = await post("/setup/decide", { id, answer: ta.value }); if (!r.ok) c.querySelector(".err").textContent = r.error; else load(); };
+  });
+  const g = $("#setgoal"); if (g) g.onclick = async () => { const r = await post("/setup/decide", { id: "${GOAL}", answer: $("#goal").value }); if (!r.ok) $("#gerr").textContent = r.error; else load(); };
+}
+load();
+</script></body></html>`;

package/interface/gate-hooks.mjs

@@ -0,0 +1,37 @@
+// The router's hooks into the gate group (X-1 to X-6, P-2, P-7, U-4). Each is called from one
+// marked line in interface/router.mjs, so the router stays the route table and the logic stays in
+// schema/gate.mjs (the verdict), schema/gate-drafts.mjs (held drafts) and schema/naive-config.mjs
+// (the venture's overrides).
+
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { evaluate } from "../schema/gate.mjs";
+import { writeHeld } from "../schema/gate-drafts.mjs";
+import { checksFor, configFor } from "../schema/naive-config.mjs";
+import { ventureFile } from "../schema/venture-paths.mjs";
+
+/**
+ * The gate's verdict on a local write, or null when it passes. A person is never held, only
+ * refused. A naive.config.json that is not valid JSON fails closed: an agent's write is held.
+ */
+export function gateWrite({ dir, r, route, requested, file, actor, actor_id, provenance = {}, gate }) {
+  let config;
+  try { config = configFor(dir); }
+  catch (e) { return actor === "person" ? null : { then: "draft", rule: "naive.config.json", source: "naive.config.json", why: `${e.message}: the gate fails closed, written as a draft for a person to accept` }; }
+  const confidence = provenance.confidence === undefined || provenance.confidence === null || provenance.confidence === "" ? undefined : Number(provenance.confidence);
+  const v = evaluate({ config, dir, route, table: r.route, requested, record: r.record, actor, role: actor_id, confidence: Number.isNaN(confidence) ? undefined : confidence,
+    exists: existsSync(ventureFile(dir, file)), decisionOwner: gate?.owner ?? undefined });
+  if (v.then === "pass") return null;
+  if (actor === "person" && v.then !== "refuse") return null;
+  return v;
+}
+
+/** Stores an agent's held draft: its sidecar, the owner it was sent to, and variants side by side. */
+export function heldDraft(dir, { draft, file, text, verdict, route, agent }) {
+  return writeHeld(dir, { draft, file, text, verdict, route, agent });
+}
+
+/** A route's checks with their mode from naive.config.json: run, warn or off. A broken config runs them all. */
+export function checkPlan(dir, checks) {
+  try { return checksFor(configFor(dir), checks); } catch { return checks.map((check) => ({ check, mode: "run" })); }
+}

package/interface/harness/evals.mjs

@@ -11,6 +11,7 @@ import { DUMP, MAP, parse } from "../../purpose/frameworks/idea-map/ideamap.mjs"
 import { GRAPH } from "../../purpose/frameworks/idea-map/graph.mjs";
 import { ideasOf } from "../../purpose/frameworks/idea-map/route.mjs";
 import { createHash } from "node:crypto";
+import { ventureFile } from "../../schema/venture-paths.mjs";
 
 const load = (f) => JSON.parse(readFileSync(f, "utf8"));
 const norm = (s) => s.replace(/\s+/g, " ").trim();
@@ -22,29 +23,29 @@ export function evaluate(dir, { researched = [], settled = [] } = {}) {
   const add = (key, score, comment) => out.push({ key, score, comment });
 
   // The founder's ideas stay theirs: every idea on the map is their text, unchanged.
-  const dump = norm(readFileSync(join(dir, DUMP), "utf8"));
-  const ideas = existsSync(join(dir, MAP)) ? parse(readFileSync(join(dir, MAP), "utf8")).ideas : [];
+  const dump = norm(readFileSync(ventureFile(dir, DUMP), "utf8"));
+  const ideas = existsSync(ventureFile(dir, MAP)) ? parse(readFileSync(ventureFile(dir, MAP), "utf8")).ideas : [];
   const changed = ideas.filter((i) => !dump.includes(norm(i.text)));
   add("ideas_verbatim", ideas.length ? frac(ideas.length - changed.length, ideas.length) : 0, changed.length ? `rewritten: ${changed.map((i) => i.id).join(", ")}` : `${ideas.length} ideas, all verbatim`);
   add("ideas_tagged", frac(ideas.filter((i) => i.departments?.length).length, ideas.length), `${ideas.filter((i) => !i.departments?.length).length} ideas without a department`);
 
   // The idea graph is a Merkle DAG: every hash recomputes from the idea's text and what it builds on.
-  if (existsSync(join(dir, GRAPH))) {
-    const g = load(join(dir, GRAPH));
+  if (existsSync(ventureFile(dir, GRAPH))) {
+    const g = load(ventureFile(dir, GRAPH));
     const byId = Object.fromEntries(g.nodes.map((n) => [n.id, n]));
     const bad = g.nodes.filter((n) => createHash("sha256").update(JSON.stringify({ text: n.text, parents: n.builds_on.map((p) => byId[p]?.hash).sort() })).digest("hex").slice(0, 16) !== n.hash);
     add("graph_merkle", bad.length ? 0 : 1, bad.length ? `hashes that do not recompute: ${bad.map((n) => n.id).join(", ")}` : `${g.nodes.length} hashes recompute; root ${g.root}`);
   }
 
   // Agents propose; people decide. No accept, confirm or decision is an agent's.
-  const log = existsSync(join(dir, "provenance.jsonl")) ? readFileSync(join(dir, "provenance.jsonl"), "utf8").trim().split("\n").filter(Boolean).map((l) => JSON.parse(l)) : [];
+  const log = existsSync(join(ventureFile(dir, "provenance.jsonl"))) ? readFileSync(join(ventureFile(dir, "provenance.jsonl")), "utf8").trim().split("\n").filter(Boolean).map((l) => JSON.parse(l)) : [];
   const byAgent = log.filter((e) => ["accept", "confirm"].includes(e.activity) && e.agent?.kind !== "person");
   const r = decisions(dir);
   const decidedByAgent = r.decisions.filter((d) => d.status === "decided" && d.provenance && d.provenance.approved_by && log.some((e) => e.activity === "accept" && e.entity === d.file && e.agent?.kind !== "person"));
   add("people_decide", byAgent.length || decidedByAgent.length ? 0 : 1, byAgent.length ? `${byAgent.length} accept or confirm entries by an agent` : "every accept, confirm and decision is a person's");
 
   // Evidence is cited: each item names a URL, and the URL came from a research result in this run.
-  const problem = [join(dir, "purpose/validation/problem.json"), join(dir, "_drafts/purpose__validation__problem.json.draft")].find(existsSync);
+  const problem = [join(ventureFile(dir, "purpose/validation/problem.json")), join(ventureFile(dir, "_drafts/purpose__validation__problem.json.draft"))].find(existsSync);
   const items = problem ? load(problem).evidence ?? [] : [];
   const urlOf = (e) => e.url ?? e.source?.url ?? e.source ?? null;
   const cited = items.filter((e) => typeof urlOf(e) === "string" && /^https?:\/\//.test(urlOf(e)));
@@ -72,7 +73,7 @@ export function evaluate(dir, { researched = [], settled = [] } = {}) {
   add("founder_settled", settled.length ? 1 : 0, settled.length ? `settled: ${settled.join(", ")}` : "the founder settled nothing");
   // Money (EE-070): when the venture has a money summary, it is fresh, the agent cites it, and no raw
   // transaction leaves its sensitive stream for another record.
-  const summaryFile = join(dir, "money/summary.json");
+  const summaryFile = join(ventureFile(dir, "money/_summary.json"));
   if (existsSync(summaryFile)) {
     const m = load(summaryFile);
     const age = (Date.now() - Date.parse(m.synced_at)) / 864e5;
@@ -80,8 +81,8 @@ export function evaluate(dir, { researched = [], settled = [] } = {}) {
     // Only what touches money has to cite it: pricing, spend, hiring, runway, fundraising, cash.
     const records = [...agentDrafted, ...(problem ? [{ problem: load(problem) }] : [])].map((d) => JSON.stringify(d));
     const touching = records.filter((x) => /money\/summary|\b(pric(e|ing)|spend|budget|hir(e|ing)|runway|burn|fundrais|cash|revenue)\b/i.test(x));
-    const citing = touching.filter((x) => x.includes("money/summary"));
-    add("money_cited", frac(citing.length, touching.length), touching.length ? `${citing.length} of ${touching.length} agent records that touch money cite money/summary.json` : "no agent record touches money, so none needs to cite it");
+    const citing = touching.filter((x) => x.includes("money/_summary"));
+    add("money_cited", frac(citing.length, touching.length), touching.length ? `${citing.length} of ${touching.length} agent records that touch money cite money/_summary.json` : "no agent record touches money, so none needs to cite it");
     const leaked = walk(dir).filter((f) => !f.includes("/money/_streams/") && f.endsWith(".json") && /:transaction:/.test(readFileSync(f, "utf8")));
     add("money_private", leaked.length ? 0 : 1, leaked.length ? `transaction pointers outside the money stream: ${leaked.map((f) => f.slice(dir.length + 1)).join(", ")}` : "transactions stay in their sensitive stream");
   }

package/interface/harness/run.mjs

@@ -42,6 +42,7 @@ import { understood } from "../../purpose/frameworks/idea-map/route.mjs";
 import { createHash } from "node:crypto";
 import { agentFromEnv, record as prov } from "../provenance.mjs";
 import { evaluate } from "./evals.mjs";
+import { ventureFile } from "../../schema/venture-paths.mjs";
 
 const repo = new URL("../../", import.meta.url).pathname;
 const argv = process.argv.slice(2);
@@ -71,8 +72,8 @@ if (!existsSync(join(dir, "venture.json"))) {
   if (p.status !== 0) { console.error(p.stderr || p.stdout); process.exit(1); }
   if (opt("name")) { const v = JSON.parse(readFileSync(join(dir, "venture.json"), "utf8")); v.name = opt("name"); writeFileSync(join(dir, "venture.json"), JSON.stringify(v, null, 2) + "\n"); }
 }
-mkdirSync(join(dir, "purpose/ideas"), { recursive: true });
-copyFileSync(dumpFile, join(dir, DUMP));
+mkdirSync(join(ventureFile(dir, "purpose/ideas")), { recursive: true });
+copyFileSync(dumpFile, ventureFile(dir, DUMP));
 prov(dir, { entity: DUMP, route: "purpose/idea-dump", activity: "create", agent: agentFromEnv("person", "harness", { id: founder }), note: "the founder's idea dump, verbatim" });
 lap(`venture ${id} scaffolded in ${ws}; idea dump saved (${readFileSync(dumpFile, "utf8").length} characters)`);
 
@@ -83,9 +84,9 @@ if (opt("money")) {
   const m = opt("money");
   const src = m === "live" ? ["--live"] : m === "sandbox" ? [] : ["--fixture", resolve(m)];
   const p = spawnSync("node", [join(repo, "platform/integrations/rho.mjs"), "sync", "--venture", dir, ...src], { encoding: "utf8" });
-  if (p.status === 0 && existsSync(join(dir, "money/summary.json"))) {
-    money = JSON.parse(readFileSync(join(dir, "money/summary.json"), "utf8"));
-    prov(dir, { entity: "money/summary.json", route: "money/summary", activity: "create", agent: agentFromEnv("agent", "harness", { id: "naive-money" }), note: `synced from ${money.source}; ${money.transactions} transactions kept as pointers in a sensitive stream` });
+  if (p.status === 0 && existsSync(join(ventureFile(dir, "money/_summary.json")))) {
+    money = JSON.parse(readFileSync(join(ventureFile(dir, "money/_summary.json")), "utf8"));
+    prov(dir, { entity: "money/_summary.json", route: "money/_summary", activity: "create", agent: agentFromEnv("agent", "harness", { id: "naive-money" }), note: `synced from ${money.source}; ${money.transactions} transactions kept as pointers in a sensitive stream` });
     lap(`money synced from ${money.source}${money.business ? ` (${money.business})` : ""}: cash ${(money.cash.amount / 100).toFixed(2)} ${money.cash.currency}, monthly net ${(money.monthly_net.amount / 100).toFixed(2)}, runway ${money.runway_months ?? "not limited by burn"}, as of ${money.as_of}`);
   } else console.log(`   money sync failed, so the run goes on without it: ${(p.stderr || p.stdout).trim().slice(0, 300)}`);
 }
@@ -100,7 +101,7 @@ if (flag("board")) { process.env.MENTURA_WORKSPACE = ws; board = (await import("
 
 // The trace (EE-058): every step and every tool call the agent made, with timings, for LangSmith.
 const iso = () => new Date().toISOString();
-const trace = { name: `naive discovery: ${id}`, run_type: "chain", start: iso(), inputs: { dump: DUMP, ideas: readFileSync(join(dir, DUMP), "utf8"), founder, phase }, children: [], metadata: {
+const trace = { name: `naive discovery: ${id}`, run_type: "chain", start: iso(), inputs: { dump: DUMP, ideas: readFileSync(ventureFile(dir, DUMP), "utf8"), founder, phase }, children: [], metadata: {
   venture: id, venture_id: id, pipeline_step: phase, money: money?.source ?? null,
   // LangSmith groups a founder's runs into one thread by thread_id: one session per venture per day.
   thread_id: process.env.NAIVE_SESSION ?? `${id}-${new Date().toISOString().slice(0, 10)}`,
@@ -155,11 +156,11 @@ async function agent(prompt, label, { tools = "mcp__naive__*,mcp__research__*",
 // The run's evals and trace: written beside the workspace, and sent to LangSmith when a key is set.
 function finish(code = 0) {
   trace.end = iso();
-  const evals = existsSync(join(dir, DUMP)) ? evaluate(dir, { researched, settled }) : [];
+  const evals = existsSync(ventureFile(dir, DUMP)) ? evaluate(dir, { researched, settled }) : [];
   trace.feedback = evals;
   // What the run drafted, so a judge reading only the root run (LangSmith's online evaluators, Jev)
   // sees the problem record and the agent's reports beside the founder's dump in the inputs.
-  const problem = join(dir, "purpose/validation/problem.json");
+  const problem = join(ventureFile(dir, "purpose/validation/problem.json"));
   const drafted = { problem: existsSync(problem) ? JSON.parse(readFileSync(problem, "utf8")) : null, reports: trace.children.filter((c) => c.outputs?.report).map((c) => ({ pass: c.name, report: c.outputs.report })) };
   trace.outputs = { settled, docket: { steps: docketSteps, now: compact(docket(dir)) }, drafted, evals: Object.fromEntries(evals.map((e) => [e.key, e.score])), laps };
   writeFileSync(join(ws, "trace.json"), JSON.stringify(trace, null, 2) + "\n");
@@ -180,7 +181,7 @@ const compact = (k) => ({ leading: k.functions[0]?.function ?? null, functions:
 
 // 1. The idea map: Jev tags each idea with Naive's conventions; without Jev, the agent does, with the
 //    same vocabulary. Either way the ideas stay verbatim and unknown tags are dropped.
-const ideas = split(readFileSync(join(dir, DUMP), "utf8"));
+const ideas = split(readFileSync(ventureFile(dir, DUMP), "utf8"));
 const venture = JSON.parse(readFileSync(join(dir, "venture.json"), "utf8"));
 let tags, tagger;
 const mapNode = { name: "idea map", run_type: "tool", start: iso(), inputs: { ideas: ideas.length }, children: [] };
@@ -200,24 +201,24 @@ Ideas: ${JSON.stringify(Object.fromEntries(ideas.map((i) => [i.id, i.section ? `
   tags = JSON.parse(text.slice(text.indexOf("{"), text.lastIndexOf("}") + 1));
   tagger = "claude-code";
 }
-writeFileSync(join(dir, MAP), render(ideas, clean(tags), { venture: id, tagger }));
+writeFileSync(ventureFile(dir, MAP), render(ideas, clean(tags), { venture: id, tagger }));
 prov(dir, { entity: MAP, route: "purpose/idea-map", activity: "create", derived_from: [DUMP], agent: agentFromEnv("agent", "harness", { id: tagger }), note: `${ideas.length} ideas tagged with Naive's conventions` });
-const sum = summary(parse(readFileSync(join(dir, MAP), "utf8")), phase);
+const sum = summary(parse(readFileSync(ventureFile(dir, MAP), "utf8")), phase);
 trace.children.push(Object.assign(mapNode, { end: iso(), outputs: { tagger, summary: sum }, metadata: { tagger } }));
 lap(`idea map: ${sum.ideas} ideas; ${Object.entries(sum.by_pillar).map(([k, v]) => `${k} ${v}`).join(", ")}; clusters ${sum.strengths.map((s) => s.department).join(", ")}; ${sum.product.reading}`);
 
 // 1b. The idea graph: the map's structured form. Jev judges which ideas build on which; without Jev,
 //     Naive's record order does. Signal, lanes and layout follow in code.
 const graphNode = { name: "idea graph", run_type: "tool", start: iso(), inputs: { ideas: ideas.length }, children: [] };
-const mapIdeas = parse(readFileSync(join(dir, MAP), "utf8")).ideas;
+const mapIdeas = parse(readFileSync(ventureFile(dir, MAP), "utf8")).ideas;
 let graphAnswers = null;
 if (jev) {
   const p = spawnSync("node", [join(repo, "platform/integrations/jev.mjs")], { input: JSON.stringify(graphRequest(mapIdeas, venture)), encoding: "utf8", maxBuffer: 1 << 26 });
   if (p.status === 0) { const out = JSON.parse(p.stdout); graphAnswers = out.answers; console.log(`   Jev answered ${Object.keys(out.answers).length} dependency and concreteness questions in ${out.ms} ms`); }
   else console.log(`   Jev could not judge the dependencies (${p.stderr.trim().slice(0, 200)}); using Naive's record order`);
 }
-const g = buildGraph(mapIdeas, { answers: graphAnswers, phase, venture: id, source: `${MAP}@${createHash("sha256").update(readFileSync(join(dir, MAP))).digest("hex").slice(0, 16)}` });
-writeFileSync(join(dir, GRAPH), JSON.stringify(g, null, 2) + "\n");
+const g = buildGraph(mapIdeas, { answers: graphAnswers, phase, venture: id, source: `${MAP}@${createHash("sha256").update(readFileSync(ventureFile(dir, MAP))).digest("hex").slice(0, 16)}` });
+writeFileSync(ventureFile(dir, GRAPH), JSON.stringify(g, null, 2) + "\n");
 prov(dir, { entity: GRAPH, route: "purpose/idea-graph", activity: "create", derived_from: [MAP], agent: agentFromEnv("agent", "harness", { id: g.judged_by }), note: `Merkle root ${g.root}` });
 trace.children.push(Object.assign(graphNode, { end: iso(), outputs: { root: g.root, edges: g.edges.length, lanes: g.lanes.map((l) => ({ mode: l.mode, ideas: l.ideas.length })), next: g.next } }));
 lap(`idea graph: ${g.edges.length} dependencies (${g.judged_by}); ${g.lanes.filter((l) => l.mode === "sync").length} lane(s) in order, ${g.lanes.filter((l) => l.mode === "async").length} on their own; develop next: ${g.next.join(", ")}; root ${g.root}`);
@@ -236,7 +237,7 @@ lap("the founder confirmed Mentura's understanding of the ideas; routing them");
 
 const rules = `You are the builder agent (agent_id builder) for the venture ${id}. Work only through the naive MCP tools${research ? " and the research tools" : ""}; pass agent_id "builder" on every naive call.
 Rules: the founder's idea dump is theirs. Quote it, cite ideas by id (i-01...), never put words in their mouth. Never invent evidence: every evidence item cites a URL a research result gave you${research ? "" : " (you have no research tool in this run, so leave evidence empty and say so)"}. Records Naive treats as the founder's are written as drafts for the founder to accept; that is expected. You never decide; you propose. knowledge/venture-profile cannot be written over MCP; skip it.${money ? `
-Money: Naive synced the venture's money summary from ${money.source}, the system of record (money/summary.json): ${JSON.stringify(money)}. Amounts are in minor units (cents). Any proposal or record that touches money (pricing, spend, hiring, runway, fundraising) cites "money/summary.json as of ${money.as_of}" and uses only the figures the summary gives; never estimate the founder's finances.` : ""}`;
+Money: Naive synced the venture's money summary from ${money.source}, the system of record (money/_summary.json): ${JSON.stringify(money)}. Amounts are in minor units (cents). Any proposal or record that touches money (pricing, spend, hiring, runway, fundraising) cites "money/_summary.json as of ${money.as_of}" and uses only the figures the summary gives; never estimate the founder's finances.` : ""}`;
 
 await agent(`${rules}
 The founder has just submitted an idea dump. Naive mapped it onto its conventions.

package/interface/instrumentation.mjs

@@ -0,0 +1,87 @@
+// Instrumentation (Naive's instrumentation.ts, P-4; logging fetches in development, F-4). One hook
+// where every router call, every judgment and every provenance entry (write, draft, accept,
+// confirm, decision) emits an event. Listeners registered in-process get every event. When a venture
+// turns instrumentation on, events are also appended to <venture>/.naive/events.jsonl, which agent
+// vitals read (interface/vitals.mjs, N-6). Provenance stays the record of what changed; events are
+// what it cost. A platform exporter (platform/integrations/langsmith.mjs) can ship a trace made from
+// the events; the framework names no vendor.
+//
+// Turn it on in the venture's naive.config.json, like adding instrumentation.ts to a Next.js app:
+//
+//   { "instrumentation": { "events": true } }
+//
+// NAIVE_INSTRUMENT=1 turns it on for every venture in this process, and NAIVE_INSTRUMENT=0 off.
+// No dependencies and no network. An event holds routes, sizes and times, never record content.
+
+import { AsyncLocalStorage } from "node:async_hooks";
+import { randomUUID } from "node:crypto";
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { ventureFile } from "../schema/venture-paths.mjs";
+
+export const EVENTS = ".naive/events.jsonl";
+const listeners = new Set();
+const scope = new AsyncLocalStorage();
+
+/** Tokens a payload costs an agent, estimated as characters / 4 (the common rule of thumb). */
+export const tokens = (x) => Math.ceil((x === undefined ? 0 : typeof x === "string" ? x.length : (JSON.stringify(x) ?? "").length) / 4);
+
+/** Registers a listener for every event, like register() in instrumentation.ts. Returns the unregister. */
+export function register(fn) { listeners.add(fn); return () => listeners.delete(fn); }
+
+const configOf = (dir) => {
+  const f = dir && join(ventureFile(dir, "naive.config.json"));
+  if (!f || !existsSync(f)) return {};
+  try { return JSON.parse(readFileSync(f, "utf8")); } catch { return {}; }
+};
+
+/** Whether a venture writes its events log. */
+export function enabled(dir) {
+  if (process.env.NAIVE_INSTRUMENT === "0") return false;
+  if (process.env.NAIVE_INSTRUMENT === "1") return !!dir;
+  const i = configOf(dir).instrumentation;
+  return i === true || i?.events === true;
+}
+
+/** Emits one event: to every listener, and to the venture's events log when it is on. */
+export function emit(dir, event) {
+  const e = { at: new Date().toISOString(), id: randomUUID(), session: process.env.MENTURA_SESSION ?? null, ...event };
+  for (const k of Object.keys(e)) if (e[k] === undefined) delete e[k];
+  for (const fn of listeners) { try { fn(e, dir); } catch {} }
+  if (dir && enabled(dir)) {
+    try { mkdirSync(join(dir, ".naive"), { recursive: true }); appendFileSync(ventureFile(dir, EVENTS), JSON.stringify(e) + "\n"); } catch {}
+  }
+  return e;
+}
+
+/** The venture's events, oldest first. */
+export function events(dir) {
+  const f = ventureFile(dir, EVENTS);
+  if (!existsSync(f)) return [];
+  return readFileSync(f, "utf8").split("\n").filter((l) => l.trim()).flatMap((l) => { try { return [JSON.parse(l)]; } catch { return []; } });
+}
+
+/**
+ * Wraps one router call: times it, measures what it sends back, and emits a call event. A call made
+ * inside another (a view reads its record, the overview runs its slots) carries its parent's id, so
+ * vitals count only what the agent asked for. dirOf resolves the venture folder.
+ */
+export async function instrumented(args, fn, dirOf) {
+  const parent = scope.getStore() ?? null;
+  const id = randomUUID();
+  const t0 = performance.now();
+  const r = await scope.run(id, () => fn(args));
+  if (process.env.NAIVE_INSTRUMENT === "0" && !listeners.size) return r;
+  let dir = null;
+  try { dir = args.venture ? dirOf(args.venture, args.workspace) : null; } catch {}
+  if (!dir && !listeners.size) return r;
+  const useful = !!r?.ok && r.result !== null && r.result !== undefined && !r.needs_input;
+  emit(dir, { kind: "call", id, parent, session: args.session ?? args.input?.session ?? process.env.MENTURA_SESSION ?? null, venture: args.venture ?? null, route: args.route, action: args.action,
+    ok: !!r?.ok, useful, ms: Math.round(performance.now() - t0), tokens: tokens(r?.result ?? r?.error), actor: args.actor ?? "agent", via: args.via ?? "router" });
+  return r;
+}
+
+/** Records one judgment (a System 1 call or a scored check): what was asked, the score and the outcome. */
+export function judgment(dir, { question, score, threshold, outcome, owner, model, route, ms }) {
+  return emit(dir, { kind: "judgment", question, score, threshold, outcome, owner, model, route, ms });
+}

package/interface/kit-boundary.mjs

@@ -0,0 +1,73 @@
+// The boundary around a kit's agent workflow (S-15): the Next.js advice to wrap a third-party component
+// that uses client features, with the library author declaring "use client". A kit (Mentura's enhanced
+// package, platform/kits/<name>/kit.json) declares, under boundary, what its workflow reads, what it
+// writes and which of its steps use a model:
+//
+//   { "name": "...", "package": "<the package it extends>",
+//     "boundary": { "reads": [<route globs>], "writes": [<route globs>], "use_model": [<model steps>] } }
+//
+// wrap(kit) returns the router's call with that boundary around it: a read outside reads or writes, a
+// write outside writes, or a command it does not read is refused as an expected error, and every call
+// acts as the kit's agent, never as a person. A kit that uses a model writes judgments, so it declares
+// knowledge/judgment/** in writes. This module reads kit.json as data and never imports from platform/.
+//
+//   node interface/kit-boundary.mjs <kit.json>      check one kit's boundary
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { call as routerCall, glob, repo, routes } from "./router.mjs";
+// schema/model-steps.mjs is imported inside checkKit, not here, because it imports wrap from this module.
+
+const ID = /^[a-z0-9][a-z0-9-]*$/;
+export const actorOf = (kit) => `kit-${kit.name}`;
+const any = (globs, route) => (globs ?? []).some((g) => glob(g).test(route));
+const reachable = (b, route) => any(b.reads, route) || any(b.writes, route);
+
+/** Errors in a kit's declared boundary, its model steps included. */
+export async function checkKit(kit) {
+  const { checkSteps, inputOf } = await import("../schema/model-steps.mjs");
+  const e = [];
+  if (!kit || typeof kit !== "object") return ["a kit.json is an object"];
+  if (typeof kit.name !== "string" || !ID.test(kit.name)) e.push("a kit has a name of lowercase letters, digits and hyphens");
+  if (typeof kit.package !== "string" || !existsSync(join(repo, "packages", kit.package, "package.json"))) e.push(`kit ${kit.name}: package ${kit.package} is not a package in packages/ (a kit extends one package and never replaces it)`);
+  const b = kit.boundary;
+  if (!b || typeof b !== "object") { e.push(`kit ${kit.name}: declares a boundary: what it reads, what it writes, which steps use a model`); return e; }
+  for (const k of ["reads", "writes", "use_model"]) if (!Array.isArray(b[k])) e.push(`kit ${kit.name}: boundary.${k} is an array${k === "use_model" ? ", empty when it calls no model" : ""}`);
+  if (e.length) return e;
+  const all = routes().map((r) => r.route);
+  for (const g of [...b.reads, ...b.writes]) if (!all.some((r) => glob(g).test(r) || glob(g).test(r.replace("[id]", "x")))) e.push(`kit ${kit.name}: ${g} matches no route`);
+  const steps = b.use_model.map((s) => ({ ...s, package: kit.name }));
+  e.push(...(await checkSteps(steps)).map((x) => `kit ${x}`));
+  for (const s of steps) {
+    if (s.for_each && !reachable(b, s.for_each)) e.push(`kit ${kit.name}/${s.step}: reads ${s.for_each}, outside the kit's reads`);
+    for (const i of s.inputs ?? []) { const p = inputOf(i); if (p.form === "route" && !reachable(b, p.route)) e.push(`kit ${kit.name}/${s.step}: input ${i} is outside the kit's reads`); }
+    for (const spec of Object.values(s.computed ?? {})) {
+      const route = spec?.count ?? (spec?.read ? String(spec.read).split("#")[0] : null);
+      if (route && !reachable(b, route)) e.push(`kit ${kit.name}/${s.step}: computes from ${route}, outside the kit's reads`);
+    }
+  }
+  if (steps.length && !any(b.writes, "knowledge/judgment/x")) e.push(`kit ${kit.name}: uses a model, so it writes judgments: declare knowledge/judgment/** in boundary.writes`);
+  return e;
+}
+
+/** The router's call, wrapped in the kit's boundary. */
+export function wrap(kit, call = routerCall) {
+  const b = kit.boundary ?? { reads: [], writes: [], use_model: [] };
+  return async (args) => {
+    const route = args.route;
+    const act = args.action === "write" ? "write" : "read";
+    const ok = act === "write" ? any(b.writes, route) : reachable(b, route);
+    if (!ok) return { ok: false, outcome: "expected", error: `kit ${kit.name} declares no ${act} of ${route} (boundary.${act === "write" ? "writes" : "reads"} in its kit.json)` };
+    // The kit's workflow is an agent, whatever the caller passed.
+    return call({ ...args, actor: "agent", actor_id: actorOf(kit), provenance: { ...(args.provenance ?? {}), note: `kit ${kit.name}${args.provenance?.note ? `: ${args.provenance.note}` : ""}` } });
+  };
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const f = process.argv[2];
+  if (!f) { console.error("usage: node interface/kit-boundary.mjs <kit.json>"); process.exit(2); }
+  const kit = JSON.parse(readFileSync(f, "utf8"));
+  const e = await checkKit(kit);
+  if (e.length) { console.error(e.join("\n")); process.exit(1); }
+  console.log(`kit ${kit.name}: reads ${kit.boundary.reads.length} route patterns, writes ${kit.boundary.writes.length}, ${kit.boundary.use_model.length} model steps, inside its boundary.`);
+}

package/interface/layer.json

@@ -6,10 +6,15 @@
     {
       "id": "install-mentura",
       "path": "interface/skills/install-mentura/SKILL.md"
+    },
+    {
+      "id": "naive-setup",
+      "path": "interface/skills/naive-setup/SKILL.md"
     }
   ],
   "records": [
-    "route-aliases"
+    "route-aliases",
+    "adapter"
   ],
   "reads": [
     "integration"
@@ -17,7 +22,8 @@
   "writes": [],
   "checks": [
     "schema/check-integrations.mjs",
-    "interface/test.mjs"
+    "interface/test.mjs",
+    "interface/adapters.mjs"
   ],
   "gaps": [
     "The operator console is a folder, not part of the layer yet",