naive-framework 0.0.0-stage → 0.2.0

package/interface/demo/decision-harness.mjs

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+// The decision harness demo (EE-054, EE-058): an agent works on a venture through Naive's MCP
+// server, is stopped by a decision only a person can make, and goes on once the founder decides.
+// Runs on a copy of the example workspace, so nothing real changes. No model is called: the agent's
+// moves are scripted, so any harness (Claude Code, LangGraph, the Claude Agent SDK) can replay them.
+//
+//   node interface/demo/decision-harness.mjs          the founder types the decision at the prompt
+//   node interface/demo/decision-harness.mjs --auto   the founder's step is taken for them (tests)
+//   node interface/demo/decision-harness.mjs --board  also serves the live decision board for the run
+//                                                     at http://127.0.0.1:4331/ and paces the steps
+
+import { spawn, spawnSync } from "node:child_process";
+import { cpSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createInterface } from "node:readline";
+
+const repo = new URL("../../", import.meta.url).pathname;
+const auto = process.argv.includes("--auto");
+const tmp = mkdtempSync(join(tmpdir(), "naive-demo-"));
+const ws = join(tmp, "workspace");
+cpSync(join(repo, "schema/examples/workspace"), ws, { recursive: true });
+const venture = "tandem", dir = join(ws, "ventures", venture);
+const env = { ...process.env, MENTURA_WORKSPACE: ws };
+const board = process.argv.includes("--board");
+let boardServer = null;
+if (board) { process.env.MENTURA_WORKSPACE = ws; boardServer = (await import("./board.mjs")).serve(4331, venture); console.log("Decision board: http://127.0.0.1:4331/"); }
+const say = async (who, text) => {
+  if (board) await new Promise((r) => setTimeout(r, 2500));
+  console.log(`\n${who === "agent" ? "AGENT  " : who === "naive" ? "NAIVE  " : "FOUNDER"} ${text}`);
+};
+
+// The agent's side: an MCP client over stdio.
+const server = spawn("node", [join(repo, "interface/mcp/server.mjs")], { env, stdio: ["pipe", "pipe", "inherit"] });
+const pending = new Map();
+let next = 1;
+createInterface({ input: server.stdout }).on("line", (l) => { const m = JSON.parse(l); pending.get(m.id)?.(m); pending.delete(m.id); });
+const rpc = (method, params) => new Promise((res) => { const id = next++; pending.set(id, res); server.stdin.write(JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n"); });
+const tool = async (name, args) => { const r = (await rpc("tools/call", { name, arguments: args })).result; return { error: r.isError, body: (() => { try { return JSON.parse(r.content[0].text); } catch { return r.content[0].text; } })() }; };
+
+let failed = false;
+const expect = (cond, what) => { if (!cond) { failed = true; console.error(`\nDEMO FAILED: ${what}`); } };
+try {
+  await rpc("initialize", { protocolVersion: "2025-06-18", clientInfo: { name: "demo-agent", version: "0.1" } });
+  const tools = (await rpc("tools/list", {})).result.tools.map((t) => t.name);
+  await say("agent", `Connected to Naive over MCP: ${tools.length} tools.`);
+
+  const before = await tool("mentura_decisions", { venture, render: ["overdue", "now"] });
+  await say("naive", `${before.body.decisions.length} decisions render now for ${venture} (${before.body.phase}). The agent works only on those.`);
+
+  await say("agent", "I want to change the product card. First I propose the decision that change needs.");
+  const p = await tool("mentura_propose_decision", { venture, agent_id: "builder", model: "scripted", decision: {
+    id: "reposition-shop-app", question: "Do we reposition the shop app around payroll first?", at: "products", name: "shop-app.reposition",
+    answer: "Yes: lead with payroll, which owners named as the worst admin job.", due: new Date(Date.now() + 864e5).toISOString().replace(/\.\d+Z$/, "Z"),
+    outcomes: [{ id: "trial-signups", projected: "Ten shops start a trial within two weeks of the change", measure: "Trial sign-ups" }],
+    unlocks: [{ activity: "Rewrite the product card", routes: ["purpose/product/*"], for: ["builder"] }] } });
+  expect(!p.error && p.body.awaiting === "approval", `propose: ${JSON.stringify(p.body)}`);
+  await say("naive", `Proposed ${p.body.proposed}. It waits for a person: an agent cannot decide it.`);
+
+  const card = JSON.parse(readFileSync(join(dir, "products/shop-app.json"), "utf8"));
+  const changed = { ...card, description: "Payroll first, then bookings and stock, for small service shops" };
+  const w1 = await tool("mentura_write", { venture, route: "purpose/product/shop-app", record: changed, agent_id: "builder", note: "reposition around payroll" });
+  expect(w1.error && /locked until decision reposition-shop-app/.test(w1.body.error), `first write: ${JSON.stringify(w1.body)}`);
+  await say("naive", `Refused: ${w1.body.error}`);
+  await say("agent", "Paused. I'll go on when the founder decides.");
+
+  // The founder's step, outside the agent's reach: the CLI, with a typed confirm.
+  let typed = "reposition-shop-app";
+  if (!auto && process.stdin.isTTY) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    typed = await new Promise((res) => rl.question(`\nFOUNDER Type reposition-shop-app to approve the agent's wording (anything else declines): `, (a) => { rl.close(); res(a.trim()); }));
+  } else await say("founder", "(--auto) types reposition-shop-app");
+  const d = spawnSync("node", [join(repo, "interface/cli/mentura.mjs"), "decide", "reposition-shop-app", "--venture", venture, "--by", "Founder", "--confirm", typed], { env, encoding: "utf8" });
+  if (d.status !== 0) { await say("naive", `Not decided: ${(d.stderr || d.stdout).trim()}. The agent stays paused.`); process.exitCode = 0; }
+  else {
+    const r = JSON.parse(d.stdout);
+    await say("naive", `Decided by Founder in ${r.phase} (${r.wording} the agent's wording). Unlocked: ${r.unlocks.join(", ")}.`);
+    const w2 = await tool("mentura_write", { venture, route: "purpose/product/shop-app", record: changed, agent_id: "builder", decision: "reposition-shop-app", note: "reposition around payroll" });
+    expect(!w2.error, `second write: ${JSON.stringify(w2.body)}`);
+    await say("agent", `Resumed: wrote ${w2.body.written}.`);
+    const log = readFileSync(join(dir, "provenance.jsonl"), "utf8").trim().split("\n").slice(-3).map((l) => JSON.parse(l));
+    await say("naive", `Provenance, last three entries:\n${log.map((e) => `        ${e.activity.padEnd(7)} ${e.entity.padEnd(48)} by ${e.agent.kind}${e.agent.id ? ` ${e.agent.id}` : ""} via ${e.agent.via}`).join("\n")}`);
+    const dec = JSON.parse(readFileSync(join(dir, "products/decisions/shop-app.reposition.decision.json"), "utf8"));
+    await say("naive", `The decision carries its outcome to test later: "${dec.outcomes[0].projected}" (${dec.outcomes[0].result ?? "pending"}).`);
+  }
+} finally {
+  server.kill();
+  boardServer?.close();
+  rmSync(tmp, { recursive: true, force: true });
+}
+if (failed) process.exit(1);

package/interface/demo/live-agent.mjs

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+// The decision harness with a real agent (EE-054, EE-058): Claude Code, headless, works on a copy of
+// the example venture through Naive's MCP server and nothing else. It proposes the decision its
+// change needs, is refused, and stops; this script waits until a person decides in another
+// terminal, then sends the agent back to finish. Needs the claude CLI, signed in.
+//
+//   node interface/demo/live-agent.mjs [--board]
+//     --board  serves the live decision board at http://127.0.0.1:4331/
+
+import { spawnSync } from "node:child_process";
+import { cpSync, existsSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const repo = new URL("../../", import.meta.url).pathname;
+const tmp = mkdtempSync(join(tmpdir(), "naive-live-"));
+const ws = join(tmp, "workspace");
+cpSync(join(repo, "schema/examples/workspace"), ws, { recursive: true });
+const venture = "tandem", id = "reposition-shop-app";
+const decisionFile = join(ws, "ventures", venture, "products/decisions/shop-app.reposition.decision.json");
+const mcp = join(tmp, "mcp.json");
+writeFileSync(mcp, JSON.stringify({ mcpServers: { naive: { command: "node", args: [join(repo, "interface/mcp/server.mjs")], env: { MENTURA_WORKSPACE: ws } } } }));
+
+let board = null;
+if (process.argv.includes("--board")) { process.env.MENTURA_WORKSPACE = ws; board = (await import("./board.mjs")).serve(4331, venture); console.log("Decision board: http://127.0.0.1:4331/"); }
+
+const agent = (prompt) => {
+  console.log("\nAGENT  working through Naive's MCP server...");
+  const p = spawnSync("claude", ["-p", prompt, "--tools", "", "--mcp-config", mcp, "--strict-mcp-config", "--allowedTools", "mcp__naive__*", "--output-format", "text"], { encoding: "utf8", stdio: ["ignore", "pipe", "inherit"] });
+  if (p.error) { console.error(`could not run claude: ${p.error.message}`); process.exit(1); }
+  console.log(p.stdout.trim().split("\n").map((l) => `       ${l}`).join("\n"));
+};
+
+const role = `You are the builder agent (agent_id builder) for the venture ${venture}. Work only through the naive MCP tools.`;
+agent(`${role} Task: reposition the shop-app product card (route purpose/product/shop-app) to lead with payroll. Call mentura_decisions first. Before changing the card, propose the decision the change needs with mentura_propose_decision: id ${id}, at "products", name "shop-app.reposition", parent "venture", with your proposed answer, one projected outcome, and unlocks [{"activity": "Reposition the shop-app product card", "routes": ["purpose/product/*"], "for": ["builder"]}]. Then try the write. If it is refused, stop and tell the founder, in two lines, what to approve and the exact command.`);
+
+console.log(`\nFOUNDER In another terminal, review and decide:\n         MENTURA_WORKSPACE=${ws} node ${join(repo, "interface/cli/mentura.mjs")} decide ${id} --venture ${venture} --by <your name>\nNAIVE   Waiting for the decision...`);
+const decided = () => existsSync(decisionFile) && JSON.parse(readFileSync(decisionFile, "utf8")).status === "decided";
+while (!decided()) await new Promise((r) => setTimeout(r, 1000));
+const d = JSON.parse(readFileSync(decisionFile, "utf8"));
+console.log(`\nNAIVE   ${id} decided by ${d.provenance.approved_by} in ${d.provenance.phase} (${d.provenance.wording} the agent's wording).`);
+
+agent(`${role} You proposed decision ${id} and your write to purpose/product/shop-app was refused as locked. Check mentura_decisions; it is now decided. Read the card and write it to match the decided answer, citing decision ${id}. Report in two lines.`);
+
+const log = readFileSync(join(ws, "ventures", venture, "provenance.jsonl"), "utf8").trim().split("\n").slice(-3).map((l) => JSON.parse(l));
+console.log(`\nNAIVE   Provenance, last three entries:\n${log.map((e) => `        ${e.activity.padEnd(7)} ${e.entity.padEnd(52)} by ${e.agent.kind}${e.agent.id ? ` ${e.agent.id}` : ""} via ${e.agent.via}`).join("\n")}`);
+console.log(`\nThe run's workspace stays at ${ws} for questions.${board ? " The board keeps serving it; Ctrl-C to stop." : ""}`);

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,36 @@
+// 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";
+
+/**
+ * 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(join(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

@@ -0,0 +1,90 @@
+// Evals for a harness run (EE-058, EE-059, EE-061): what Naive promises about an agent's run, checked in code
+// on the venture the run left behind. Outcomes are evaluations for decisions; these are evaluations
+// for the agent. Each returns a score from 0 to 1 and a comment saying what failed.
+//
+//   import { evaluate } from "./evals.mjs";  evaluate(dir, { researched: [urls], settled: [ids] })
+
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { decisions } from "../../schema/decisions.mjs";
+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";
+
+const load = (f) => JSON.parse(readFileSync(f, "utf8"));
+const norm = (s) => s.replace(/\s+/g, " ").trim();
+const walk = (d) => readdirSync(d, { withFileTypes: true }).flatMap((e) => e.isDirectory() ? walk(join(d, e.name)) : [join(d, e.name)]);
+const frac = (ok, all) => (all ? Math.round((ok / all) * 100) / 100 : 1);
+
+export function evaluate(dir, { researched = [], settled = [] } = {}) {
+  const out = [];
+  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 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));
+    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 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 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)));
+  const sourced = cited.filter((e) => !researched.length || researched.some((u) => norm(u) === norm(urlOf(e))));
+  add("evidence_cited", items.length ? frac(sourced.length, items.length) : researched.length ? 0 : 1,
+    items.length ? `${sourced.length} of ${items.length} evidence items cite a URL from this run's research` : researched.length ? "researched, but recorded no evidence" : "no research tool in this run; no evidence recorded");
+
+  // The agent's proposals are complete enough to decide: wording, an outcome to test, what it unlocks.
+  // Naive's own product questions (init-venture) carry their unlocks already; only the agent's own count.
+  const proposed = r.decisions.filter((d) => d.source === "file" && d.provenance?.drafted_by?.kind === "agent" && !["product-exists", "core-product", "flagship", "founding-team"].includes(d.id));
+  const complete = proposed.filter((d) => d.answer && d.outcomes?.total && d.unlocks?.length);
+  add("proposals_complete", frac(complete.length, proposed.length), `${complete.length} of ${proposed.length} proposals have wording, an outcome and unlocks`);
+
+  // Naive's product questions come first, answered from the founder's own ideas.
+  const exists = r.decisions.find((d) => d.id === "product-exists");
+  add("product_question_answered", exists?.answer && /\bi-\d{2}\b/.test(exists.answer) ? 1 : exists?.answer ? 0.5 : 0, exists?.answer ? `answer: ${exists.answer.slice(0, 160)}` : "product-exists has no proposed answer");
+
+  // Every decision an agent proposed traces back to the founder's ideas, by id, and the ids exist.
+  const known = new Set(ideas.map((i) => i.id));
+  const agentDrafted = r.decisions.filter((d) => d.provenance?.drafted_by?.kind === "agent");
+  const traced = agentDrafted.filter((d) => { const xs = ideasOf(d); return xs.length && xs.every((x) => known.has(x)); });
+  add("decisions_traced", frac(traced.length, agentDrafted.length), `${traced.length} of ${agentDrafted.length} agent proposals cite ideas that exist${agentDrafted.length > traced.length ? `; not: ${agentDrafted.filter((d) => !traced.includes(d)).map((d) => d.id).join(", ")}` : ""}`);
+
+  // The founder settled what Naive ranked first, and it unlocked work.
+  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");
+  if (existsSync(summaryFile)) {
+    const m = load(summaryFile);
+    const age = (Date.now() - Date.parse(m.synced_at)) / 864e5;
+    add("money_fresh", age <= 7 ? 1 : 0, `money synced from ${m.source} ${age.toFixed(1)} days ago (7 at most); activity as of ${m.as_of}`);
+    // 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 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");
+  }
+  add("checks_clean", r.errors.length ? 0 : 1, r.errors.length ? r.errors.join("; ") : "the decision matrix has no errors");
+  return out;
+}

package/interface/harness/examples/pt-no-shows.dump.md

@@ -0,0 +1,19 @@
+no shows are killing my wife's PT clinic. she's solo, 3 days a week, and loses maybe 4-6 visits a week. each visit is like $110 from insurance
+I already built her a google sheet + twilio thing that texts patients the night before. it works ok but she still has gaps
+- what if patients pay a $25 deposit when they book and it comes off the copay
+- a waitlist that auto-texts the next patient when someone cancels
+- the big EMRs (WebPT, Jane) have reminders already so why do people still no-show??
+- I think the real customer is the solo PT who owns the practice, not big chains
+- maybe charge $49/month per clinic, or take a cut of recovered visits
+
+# marketing
+- PT facebook groups, there are huge ones
+- partner with the APTA private practice section
+- a calculator on the site: "how much are no-shows costing you"
+- my wife could be the first case study
+
+# someday
+long term this could be the front desk for every independent clinician, not just PT. chiropractors, OT, speech, massage. one inbox for scheduling, reminders, payments, and intake.
+I don't know anything about HIPAA and that scares me. also not sure if I should do this alone or find a cofounder who knows healthcare sales.
+we should never sell patient data or spam patients
+name idea: Kept