naive-framework 0.0.0-stage → 0.2.0

package/schema/packages.mjs

@@ -0,0 +1,252 @@
+#!/usr/bin/env node
+// Venture packages (EE-067, EE-069): the venture's business source of truth, and the gate between
+// idea and automation. Core packages are where the records live, one per department plus the
+// foundation; each record has one home and other packages read it. Handoff packages hold no records:
+// each is a snapshot of core packages for one receiver (investors, partners, a cofounder, engineering,
+// counsel). A package is complete when a person has confirmed its required records and every record it
+// reads; then MAD's automation tier may run the work that depends on it (schema/packages.json unlocks).
+// Which packages fit depends on the phase and the venture's situation: priors per phase, raised or
+// lowered by facts (the need-now form, EE-028); facts come from the records first, and the question
+// matrix asks a reasoning model only what the records do not settle. Inside a package, a record moves
+// on its own once everything it reads first is confirmed, and waits otherwise (records.after): that is
+// what Route shows. Agents never come in a package: an agent working a package is an enhancement.
+//
+// Each record also carries its route: where the founder's ideas for it stand and the one step that
+// moves it (purpose/ideas/routes, EE-061).
+//
+//   node schema/packages.mjs <venture> [--raising] [--hiring] [--answers <jev.json>] [--write] [--json]
+//   node schema/packages.mjs request <venture>       the Jev request for the questions the records leave open
+//
+// --write renders a readable view of the venture package into <venture>/package/: venture-package.json
+// (the manifest, with its versions), README.md (the index) and one Markdown document per open package.
+// The records themselves stay where they are; the view is regenerated. The documents are internal:
+// anything public goes through its public variant (EE-064).
+
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { factsOf as needFacts, probability } from "./need-now.mjs";
+import { confirmedIn, filesOf } from "./foundation.mjs";
+import { route } from "../purpose/frameworks/idea-map/route.mjs";
+
+import { loadPackages } from "./load-packages.mjs";
+// Upgrades hook (U-5): packages a venture adopted early in naive.config.json open now.
+import { adopted } from "./naive-config.mjs";
+
+const repo = new URL("..", import.meta.url).pathname;
+const load = (p) => JSON.parse(readFileSync(p, "utf8"));
+export const PACKAGES = loadPackages(repo);
+export const OUT = "package";
+const MODEL = load(join(repo, "schema/data-model.json"));
+const PHASES = ["discovery", "validation", "beachhead", "scale", "platform"];
+const r2 = (x) => Math.round(x * 100) / 100;
+const json = (dir, f) => existsSync(join(dir, f)) ? load(join(dir, f)) : null;
+
+/** The facts the packages test: need-now's, the founder's flags, and the question matrix's answers. */
+export function situation(dir, { flags = {}, answers = null } = {}) {
+  const f = needFacts(dir);
+  const phase = PHASES.includes(f.phase) ? f.phase : "discovery";
+  const icp = json(dir, "foundation/icp.json") ?? json(dir, "purpose/icp.json");
+  const profiles = icp?.profiles ?? [];
+  const products = filesOf(dir, "product").map((p) => json(dir, p)).filter(Boolean);
+  // What the records settle, by question; undefined means they do not.
+  const settled = {
+    raising: flags.raising != null ? !!flags.raising : f.funding === "bootstrapped" ? false : undefined,
+    // A site read by site presence; a planned sitemap does not count, since the pipeline plans one for every venture.
+    site: existsSync(join(dir, "operations/marketing/site-presence.json")) || undefined,
+    partner_led: profiles.some((p) => p.reached_through?.length) || products.some((p) => (p.offered_to ?? []).some((id) => profiles.some((y) => y.reached_through?.includes(id)))) || undefined,
+    hiring: flags.hiring != null ? !!flags.hiring : f.team === "looking" ? true : undefined,
+    regulated: undefined,
+    exit_intent: json(dir, "governance/exit.json") ? true : undefined,
+  };
+  const Q = PACKAGES.questions;
+  // Jev's answers from the last written package stand, unless new answers replace them.
+  const last = existsSync(join(dir, OUT, "venture-package.json")) ? Object.fromEntries(load(join(dir, OUT, "venture-package.json")).situation.questions.filter((q) => q.p != null).map((q) => [`q:${q.id}`, { noul: q.p }])) : {};
+  answers = { ...last, ...(answers ?? {}) };
+  const questions = Q.items.filter((q) => q.phases.includes(phase)).map((q) => {
+    if (settled[q.id] !== undefined) return { ...q, value: settled[q.id], by: "records" };
+    const a = answers?.[`q:${q.id}`]?.noul;
+    if (a == null) return { ...q, value: null, by: "open" };
+    return { ...q, p: r2(a), value: a >= Q.set_at ? true : a <= Q.clear_at ? false : null, by: a >= Q.set_at || a <= Q.clear_at ? "jev" : "open" };
+  });
+  for (const q of questions) if (q.value != null) f[q.id] = q.value;
+  return { phase, facts: f, questions };
+}
+
+/** The Jev request: one typed question per fact the records leave open, over what the venture's records say. */
+export function request(dir) {
+  const { questions } = situation(dir);
+  const v = load(join(dir, "venture.json"));
+  const say = (o) => o ? JSON.stringify(o).slice(0, 1200) : null;
+  const dumpFile = ["raw/dump.md", "purpose/ideas/dump.md"].find((f) => existsSync(join(dir, f)));
+  const dump = dumpFile ? readFileSync(join(dir, dumpFile), "utf8").slice(0, 2500) : null;
+  const problem = json(dir, "foundation/problem.json") ?? json(dir, "purpose/validation/problem.json");
+  const icpRec = json(dir, "foundation/icp.json") ?? json(dir, "purpose/icp.json");
+  return { state: { venture: say({ name: v.name, phase: v.phase, ambition: v.ambition, form: v.form, core: v.core }), problem: say(problem), icp: say(icpRec),
+    products: say(filesOf(dir, "product").map((p) => json(dir, p)).filter(Boolean).map((p) => ({ name: p.name, offering: p.offering, description: p.description }))), ideas: dump,
+    guidelines: "These are one venture's own records and its founder's idea dump. Answer only from what they say; when they do not say, answer low." },
+    model: "jev-latest", questions: Object.fromEntries(questions.filter((q) => q.by === "open").map((q) => [`q:${q.id}`, { type: "noul", instructions: q.ask, criteria: { true: "Yes, the records say or clearly imply it", false: "No, or the records do not say" } }])) };
+}
+
+/** A record's state in this venture: confirmed by a person, written by an agent, waiting as a draft, or missing. */
+function stateOf(dir, type) {
+  const files = filesOf(dir, type).filter((f) => existsSync(join(dir, f)) && !(f.endsWith(".json") && ["retired", "archived"].includes(json(dir, f)?.status)));
+  const drafts = (filesOf(dir, type).length ? filesOf(dir, type) : [MODEL.records.find((r) => r.id === type)?.paths?.find((p) => p.startsWith("instance/**/"))?.slice(12)].filter(Boolean))
+    .filter((f) => !f.includes("*") && existsSync(join(dir, `_drafts/${f.replace(/\//g, "__")}.draft`)));
+  if (!files.length) return { status: drafts.length ? "draft" : "missing", files: [], drafts };
+  const confirmed = files.every((f) => confirmedIn(dir, f, null));
+  return { status: drafts.length ? "draft" : confirmed ? "confirmed" : "agent", files, drafts };
+}
+
+export const TITLES = { "venture-profile": "Venture profile", "validation-product-market-fit": "Product-market fit", "validation-operations-readiness": "Operations readiness", "marketing-sitemap": "The planned site (sitemap)",
+  "marketing-content": "Public content variants", "site-presence": "Site presence", "team-plan": "Team plan", "decision-rights": "Decision rights", "founder-agreement": "Founder agreement", "publication-policy": "Publication policy",
+  department: "Departments", handoff: "Handoffs", evidence: "Evidence", ownership: "Ownership", board: "Board", exit: "Exit", account: "Accounts" };
+const STATUS = { confirmed: 1, agent: 0.5, draft: 0.5, missing: 0 };
+
+/** Which core package each record lives in. */
+export const HOME = Object.fromEntries(Object.entries(PACKAGES.core).flatMap(([id, p]) => [...p.required, ...p.optional].map((r) => [r, id])));
+
+export function packages(dir, { flags = {}, answers = null } = {}) {
+  const v = load(join(dir, "venture.json"));
+  const { phase, facts, questions } = situation(dir, { flags, answers });
+  const next = PHASES[PHASES.indexOf(phase) + 1];
+  // Upgrades hook (U-5): a package adopted early opens now, even an experimental one Naive does not model.
+  const early = adopted(dir);
+  const adopt = (id, f) => (early.has(id) && f.in !== "now" ? { ...f, in: "now", early: true, why: `${f.why}; adopted early in naive.config.json` } : f);
+  let routes = null;
+  try { routes = route(dir); } catch { routes = null; }
+  const dest = new Map((routes?.destinations ?? []).map((d) => [d.id, d]));
+  const titleOf = (type) => dest.get(type)?.title ?? TITLES[type] ?? type.replace(/-/g, " ").replace(/^./, (c) => c.toUpperCase());
+  const states = new Map();
+  const st = (type) => (states.has(type) || states.set(type, stateOf(dir, type)), states.get(type));
+  const fitOf = (p) => {
+    const fit = r2(probability(p, phase, facts)), later = next ? r2(probability(p, next, facts)) : null;
+    const moved = (p.when ?? []).filter((w) => (!w.phase || w.phase === phase) && probability({ base: { [phase]: p.base[phase] }, when: [w] }, phase, facts) !== p.base[phase]).map((w) => w.if);
+    return { fit, next_phase: later, in: fit >= PACKAGES.fit ? "now" : later != null && later >= PACKAGES.fit ? "next" : "held", why: moved.length ? `${p.why}; here: ${moved.join(", ")}` : p.why };
+  };
+  // A record moves on its own once everything it reads first is confirmed; otherwise it waits on those.
+  const row = (type, role) => {
+    const s = st(type), d = dest.get(type);
+    const waits = (PACKAGES.records[type]?.after ?? []).filter((a) => st(a).status !== "confirmed");
+    return { record: type, title: titleOf(type), role, home: HOME[type], status: s.status, files: s.files,
+      moves: s.status === "confirmed" ? "done" : waits.length ? "waits" : "now", ...(waits.length && s.status !== "confirmed" ? { waits_on: waits, waits_on_titles: waits.map(titleOf) } : {}),
+      ...(d ? { route: { stage: d.stage, ideas: d.ideas.length, next: d.next ? { by: d.next.by, do: d.next.do, command: d.next.command } : null } } : {}) };
+  };
+  const core = Object.entries(PACKAGES.core).filter(([id, p]) => !p.not_modeled || early.has(id)).map(([id, p]) => {
+    const records = [...p.required.map((t) => row(t, "required")), ...p.optional.map((t) => row(t, "optional")), ...p.refs.map((t) => row(t, "reads"))];
+    const gate = records.filter((r) => r.role !== "optional");
+    const weight = (r) => (r.role === "optional" ? 0.5 : 1);
+    const progress = r2(records.reduce((s, r) => s + STATUS[r.status] * weight(r), 0) / records.reduce((s, r) => s + weight(r), 0));
+    const state = gate.every((r) => r.status === "confirmed") ? "complete" : gate.every((r) => r.status !== "missing") ? "review" : "building";
+    return { kind: "core", id, title: p.title, department: p.department, purpose: p.purpose, ...adopt(id, fitOf(p)), state, progress, records, planned: p.planned, unlocks: p.unlocks,
+      missing: gate.filter((r) => r.status === "missing").map((r) => r.record), to_review: gate.filter((r) => r.status === "agent" || r.status === "draft").map((r) => r.record),
+      moving: records.filter((r) => r.moves === "now" && r.role !== "reads").map((r) => r.record) };
+  });
+  const byId = Object.fromEntries(core.map((p) => [p.id, p]));
+  const handoff = Object.entries(PACKAGES.handoff).filter(([id, p]) => !p.not_modeled || early.has(id)).map(([id, p]) => {
+    const from = p.from.map((c) => byId[c]).filter(Boolean);
+    return { kind: "handoff", id, title: p.title, for: p.for, from: p.from, ...adopt(id, fitOf(p)), state: from.every((c) => c.state === "complete") ? "complete" : "building",
+      progress: r2(from.reduce((s, c) => s + c.progress, 0) / from.length), waits_on: from.filter((c) => c.state !== "complete").map((c) => c.id), unlocks: p.unlocks };
+  });
+  const order = (a, b) => ({ now: 0, next: 1, held: 2 }[a.in] - { now: 0, next: 1, held: 2 }[b.in]) || b.fit - a.fit;
+  core.sort(order); handoff.sort(order);
+  const open = core.filter((p) => p.in === "now");
+  return { version: PACKAGES.version, venture: v.id, name: v.name, phase, built_at: new Date().toISOString().replace(/\.\d+Z$/, "Z"),
+    situation: { facts: Object.fromEntries(questions.map((q) => [q.id, q.value])), questions: questions.map((q) => ({ id: q.id, ask: q.ask, value: q.value, by: q.by, ...(q.p != null ? { p: q.p } : {}), moves: q.moves })) },
+    progress: open.length ? r2(open.reduce((s, p) => s + p.progress, 0) / open.length) : 0,
+    complete: [...core, ...handoff].filter((p) => p.in === "now" && p.state === "complete").map((p) => p.id),
+    core, handoff, assumes: PACKAGES.assumes, not_modeled: [...Object.entries(PACKAGES.core), ...Object.entries(PACKAGES.handoff)].filter(([id, p]) => p.not_modeled && !early.has(id)).map(([id, p]) => ({ id, title: p.title, why: p.not_modeled })),
+    enhancements: PACKAGES.enhancements,
+    routing: routes ? { included: true, note: "Hackathon demo: each record shows where the founder's ideas for it stand and the one step that moves it (EE-061).", loose: routes.loose?.length ?? 0 } : { included: false } };
+}
+
+// Render a record as readable Markdown, whatever its shape: the package documents are for people.
+const HIDE = new Set(["$schema", "version", "venture"]);
+const label = (k) => k.replace(/[_-]+/g, " ").replace(/^./, (c) => c.toUpperCase());
+function md(x, depth = 0) {
+  const pad = "  ".repeat(depth);
+  if (x == null || x === "") return "";
+  if (typeof x !== "object") return String(x);
+  if (Array.isArray(x)) return x.map((e) => typeof e === "object" && e ? `${pad}- ${md(lead(e), 0)}\n${md(rest(e), depth + 1)}` : `${pad}- ${e}`).join("\n").replace(/\n+$/, "");
+  return Object.entries(x).filter(([k, v]) => !HIDE.has(k) && v != null && v !== "" && !(Array.isArray(v) && !v.length)).map(([k, v]) =>
+    typeof v === "object" ? `${pad}- **${label(k)}**\n${md(v, depth + 1)}` : `${pad}- **${label(k)}**: ${v}`).join("\n");
+}
+const LEAD = ["name", "title", "who", "statement", "question", "label", "id"];
+const lead = (o) => { const k = LEAD.find((k) => typeof o[k] === "string"); return k ? o[k] : ""; };
+const rest = (o) => { const k = LEAD.find((k) => typeof o[k] === "string"); return Object.fromEntries(Object.entries(o).filter(([x]) => x !== k)); };
+const body = (dir, f) => {
+  const t = readFileSync(join(dir, f), "utf8");
+  if (f.endsWith(".json")) return md(JSON.parse(t));
+  return t.replace(/^---\n[\s\S]*?\n---\n/, "").replace(/^#\s.*\n/, "").trim();
+};
+const MARK = { confirmed: "confirmed", agent: "drafted by an agent, not yet reviewed", draft: "a draft waiting for you", missing: "not written yet" };
+const STATE = { complete: "complete: its automation may run", review: "every record is written; some wait for your review", building: "still being written" };
+
+/** A new version each time a package completes or the phase changes; earlier versions are kept. */
+export function versions(dir, r) {
+  const f = join(dir, OUT, "venture-package.json");
+  const before = existsSync(f) ? load(f) : null;
+  const list = before?.versions ?? [];
+  const last = list.at(-1);
+  const done = r.complete.slice().sort();
+  const changed = !last || last.phase !== r.phase || done.some((id) => !last.complete.includes(id));
+  if (!changed) return list;
+  const n = list.length + 1;
+  return [...list, { version: n, at: r.built_at, phase: r.phase, complete: done, why: !last ? "first package" : last.phase !== r.phase ? `phase changed to ${r.phase}` : `completed: ${done.filter((id) => !last.complete.includes(id)).join(", ")}`, tag: `package/${r.venture}/v${n}` }];
+}
+
+/** Write the readable view: the manifest, the index, and one document per open core package. */
+export function write(dir, r) {
+  const out = join(dir, OUT);
+  mkdirSync(out, { recursive: true });
+  r.versions = versions(dir, r);
+  writeFileSync(join(out, "venture-package.json"), JSON.stringify(r, null, 2) + "\n");
+  const open = r.core.filter((p) => p.in === "now");
+  for (const p of open) {
+    const doc = [`# ${r.name}: ${p.title}`, "", p.purpose, "",
+      `Internal: these are the venture's own records. Anything public is a separate variant that passes the public gate (EE-064).`, "",
+      `State: ${STATE[p.state]} (${Math.round(p.progress * 100)}%). Unlocks: ${p.unlocks.join(", ")}.`, ""];
+    for (const x of p.records) {
+      doc.push(`## ${x.title}${x.role === "optional" ? " (optional)" : x.role === "reads" ? ` (read from ${PACKAGES.core[x.home]?.title ?? x.home})` : ""}`, "",
+        `*${MARK[x.status]}*${x.waits_on ? `. Waits on: ${x.waits_on.map(titleOf0).join(", ")}` : ""}${x.route?.next && x.status !== "confirmed" ? `. Next: ${x.route.next.do}` : ""}`, "");
+      if (x.role === "reads") continue;
+      for (const f of x.files) { if (x.files.length > 1) doc.push(`### ${f}`, ""); doc.push(body(dir, f) || "(empty)", ""); }
+    }
+    if (p.planned.length) doc.push("## Not in Naive yet", "", ...p.planned.map((x) => `- ${x}`), "");
+    writeFileSync(join(out, `${p.id}.md`), doc.join("\n").replace(/\n{3,}/g, "\n\n"));
+  }
+  const pct = (x) => `${Math.round(x * 100)}%`;
+  const fm = ["---", "type: venture-package", "source: generated", `created: ${r.built_at}`, "ai-model: none", `tags: [venture-package, ${r.venture}, ${r.phase}]`, `description: "${r.name}'s venture package in ${r.phase}, version ${r.versions.at(-1)?.version ?? 1} (EE-067, EE-069)."`, "---", ""];
+  const idx = [...fm, `# ${r.name}: venture package`, "", `Phase: ${r.phase}. ${pct(r.progress)} across the core packages open now. Complete, so their automation may run: ${r.complete.length ? r.complete.join(", ") : "none yet"}.`, "",
+    "## Core packages", "", "| Package | Fit now | State | Progress | Moving now | Still to write | To review |", "|---|---|---|---|---|---|---|",
+    ...r.core.filter((p) => p.in !== "held").map((p) => `| ${p.in === "now" ? `[${p.title}](${p.id}.md)` : `${p.title} (next phase)`} | ${p.fit} | ${p.state} | ${pct(p.progress)} | ${p.moving.join(", ") || "none"} | ${p.missing.join(", ") || "none"} | ${p.to_review.join(", ") || "none"} |`), "",
+    `Held: ${r.core.filter((p) => p.in === "held").map((p) => p.title).join(", ") || "none"}.`, "",
+    "## Handoff packages", "", "| Package | For | Fit now | Draws on | Waits on |", "|---|---|---|---|---|",
+    ...r.handoff.filter((p) => p.in !== "held").map((p) => `| ${p.title} | ${p.for} | ${p.fit} | ${p.from.join(", ")} | ${p.waits_on.join(", ") || "nothing: ready"} |`), "",
+    `Held: ${r.handoff.filter((p) => p.in === "held").map((p) => p.title).join(", ") || "none"}.`, "",
+    "## What decided this", "", ...r.situation.questions.map((q) => `- ${q.ask} **${q.value == null ? "open: yours to answer" : q.value ? "yes" : "no"}** (${q.by === "records" ? "from the records" : q.by === "jev" ? `Jev, ${q.p}` : "the records do not say"})`), "",
+    "## Versions", "", ...r.versions.map((x) => `- v${x.version}, ${x.at}, ${x.phase}: ${x.why}. Tag: \`${x.tag}\``), "",
+    "## Assumed", "", `- ${r.assumes.note}`, "", "## Not included", "", `- Agents. ${r.enhancements.agents}`, ...r.not_modeled.map((x) => `- ${x.title}. ${x.why}`), ""];
+  writeFileSync(join(out, "README.md"), idx.join("\n"));
+  return out;
+}
+const titleOf0 = (t) => TITLES[t] ?? t.replace(/-/g, " ");
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const args = process.argv.slice(2);
+  const opt = (n) => { const i = args.indexOf(`--${n}`); return i >= 0 ? args[i + 1] : null; };
+  const has = (n) => args.includes(`--${n}`);
+  if (args[0] === "request") { console.log(JSON.stringify(request(args[1]))); process.exit(0); }
+  const dir = args[0];
+  if (!dir || !existsSync(join(dir, "venture.json"))) { console.error("usage: node schema/packages.mjs <venture> [--raising] [--hiring] [--answers <jev.json>] [--write] [--json] | request <venture>"); process.exit(2); }
+  const answers = opt("answers") ? load(opt("answers")).answers : null;
+  const r = packages(dir, { flags: Object.fromEntries(["raising", "hiring"].filter(has).map((k) => [k, true])), answers });
+  if (has("write")) console.error(`wrote ${write(dir, r)}`);
+  if (has("json")) console.log(JSON.stringify(r, null, 2));
+  else {
+    console.log(`${r.name} (${r.phase}): ${Math.round(r.progress * 100)}% across the open core packages; complete: ${r.complete.join(", ") || "none yet"}`);
+    for (const p of r.core) console.log(`core    ${p.in.padEnd(5)} ${p.title.padEnd(22)} fit ${String(p.fit).padEnd(5)} ${p.in === "now" ? `${p.state.padEnd(9)} ${Math.round(p.progress * 100)}%  moving: ${p.moving.join(", ") || "none"}` : p.why}`);
+    for (const p of r.handoff) console.log(`handoff ${p.in.padEnd(5)} ${p.title.padEnd(22)} fit ${String(p.fit).padEnd(5)} ${p.in === "now" ? `waits on ${p.waits_on.join(", ") || "nothing"}` : p.why}`);
+    const open = r.situation.questions.filter((q) => q.value == null);
+    if (open.length) console.log(`Open: ${open.map((q) => q.ask).join(" ")}`);
+  }
+}

package/schema/payouts.mjs

@@ -0,0 +1,91 @@
+// Computes who gets what if the venture is sold, from <venture>/governance/ownership.json
+// and the scenarios in exit.json (EE-022): the preference stack. Indicative only, not
+// legal, tax or financial advice: the signed documents decide, and real deals add debt,
+// fees, escrow and earn-outs that this leaves out.
+//
+//   node schema/payouts.mjs <venture dir>              every scenario in exit.json
+//   node schema/payouts.mjs <venture dir> <value>      one sale value
+//   node schema/payouts.mjs <venture dir> --json       as data
+//
+// Rules, from standard terms (NVCA model documents; Feld and Mendelson, Venture Deals):
+// preferred classes are paid first, highest seniority first, equal ranks pro rata; a
+// non-participating preference takes the greater of its preference or converting to common;
+// a participating one takes both. A post-money SAFE or note takes the greater of its amount
+// or its as-converted share (amount over valuation cap), on par with the lowest-ranked
+// preferred. The unissued option pool is paid nothing. What is left goes pro rata to common.
+
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+export function payouts(own, value) {
+  const classes = new Map(own.classes.map((c) => [c.id, c]));
+  const kindOf = new Map(own.holders.map((h) => [h.id, h.kind]));
+  const grants = own.grants.filter((g) => kindOf.get(g.holder) !== "pool");
+  const issued = grants.reduce((n, g) => n + g.amount, 0);
+  const instruments = own.instruments ?? [];
+  const safeShare = instruments.reduce((n, i) => n + (i.valuation_cap ? i.amount / i.valuation_cap : 0), 0);
+  const ranks = own.classes.filter((c) => c.kind === "preferred").map((c) => c.liquidation?.seniority ?? 0);
+  const lowest = ranks.length ? Math.min(...ranks) : 0;
+
+  // One position per grant or instrument: its as-converted fraction and its preference.
+  const pos = [
+    ...grants.map((g) => {
+      const c = classes.get(g.class);
+      const pref = c.kind === "preferred" ? g.amount * (c.price_per_share ?? 0) * (c.liquidation?.multiple ?? 1) : 0;
+      return { holder: g.holder, of: g.class, fraction: (1 - safeShare) * g.amount / issued, pref, rank: c.liquidation?.seniority ?? 0, participating: !!c.liquidation?.participating };
+    }),
+    ...instruments.map((i) => ({ holder: i.holder, of: i.id, fraction: i.valuation_cap ? i.amount / i.valuation_cap : 0, pref: i.amount, rank: lowest, participating: false })),
+  ];
+
+  const run = (converted) => {
+    let left = value;
+    const paid = pos.map(() => 0);
+    const takesPref = (p, i) => p.pref > 0 && !converted.has(i);
+    for (const rank of [...new Set(pos.filter(takesPref).map((p) => p.rank))].sort((a, b) => b - a)) {
+      const group = pos.map((p, i) => [p, i]).filter(([p, i]) => takesPref(p, i) && p.rank === rank);
+      const owed = group.reduce((n, [p]) => n + p.pref, 0);
+      const pay = Math.min(left, owed);
+      for (const [p, i] of group) paid[i] += pay * p.pref / owed;
+      left -= pay;
+    }
+    const sharers = pos.map((p, i) => [p, i]).filter(([p, i]) => p.pref === 0 || p.participating || converted.has(i));
+    const total = sharers.reduce((n, [p]) => n + p.fraction, 0);
+    for (const [p, i] of sharers) paid[i] += total ? left * p.fraction / total : 0;
+    return paid;
+  };
+
+  // Each non-participating preference converts when converting pays it more; repeat until stable.
+  const converted = new Set();
+  for (let changed = true, guard = 0; changed && guard < 50; guard++) {
+    changed = false;
+    const now = run(converted);
+    for (const [i, p] of pos.entries()) {
+      if (p.pref === 0 || p.participating || converted.has(i)) continue;
+      const tryIt = new Set([...converted, i]);
+      if (run(tryIt)[i] > now[i] + 1e-9) { converted.add(i); changed = true; break; }
+    }
+  }
+  const paid = run(converted);
+  const byHolder = new Map();
+  for (const [i, p] of pos.entries()) byHolder.set(p.holder, (byHolder.get(p.holder) ?? 0) + paid[i]);
+  return { value, converted: [...converted].map((i) => pos[i].of), payouts: [...byHolder].map(([holder, amount]) => ({ holder, amount: Math.round(amount * 100) / 100 })) };
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const [dir, arg] = process.argv.slice(2);
+  if (!dir) { console.error("usage: node schema/payouts.mjs <venture dir> [value] [--json]"); process.exit(2); }
+  const own = JSON.parse(readFileSync(join(dir, "governance/ownership.json"), "utf8"));
+  const exitFile = join(dir, "governance/exit.json");
+  const scenarios = arg && !arg.startsWith("--") ? [{ id: "given", value: Number(arg) }]
+    : existsSync(exitFile) ? JSON.parse(readFileSync(exitFile, "utf8")).scenarios ?? [] : [];
+  if (!scenarios.length) { console.error("no scenarios: pass a value or add scenarios to governance/exit.json"); process.exit(2); }
+  const results = scenarios.map((s) => ({ scenario: s.id, ...payouts(own, s.value) }));
+  if (process.argv.includes("--json")) { console.log(JSON.stringify(results, null, 2)); process.exit(0); }
+  const names = new Map(own.holders.map((h) => [h.id, h.name]));
+  const cur = own.currency ?? "";
+  for (const r of results) {
+    console.log(`\n${r.scenario}: sale value ${r.value.toLocaleString("en-US")} ${cur}${r.converted.length ? ` (converts to common: ${r.converted.join(", ")})` : ""}`);
+    for (const p of r.payouts) console.log(`  ${(names.get(p.holder) ?? p.holder).padEnd(28)} ${p.amount.toLocaleString("en-US", { maximumFractionDigits: 0 }).padStart(14)}  ${(100 * p.amount / (r.value || 1)).toFixed(1).padStart(5)}%`);
+  }
+  console.log("\nIndicative only; the signed documents decide. Not legal, tax or financial advice.");
+}

package/schema/people.schema.json

@@ -0,0 +1,86 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "people.schema.json",
+  "title": "People",
+  "description": "The venture's people (people/people.json): who is in it, in which role, and which functions (hats) each owns. It is to human capital what venture.json is to the venture. A founder also has a file in people/founders/. Names only: no personal details.",
+  "type": "object",
+  "required": [
+    "venture",
+    "mode",
+    "people"
+  ],
+  "additionalProperties": false,
+  "properties": {
+    "venture": {
+      "type": "string"
+    },
+    "mode": {
+      "enum": [
+        "solo",
+        "team"
+      ],
+      "description": "solo: one person owns every function the venture imports"
+    },
+    "people": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "required": [
+          "id",
+          "name",
+          "role",
+          "hats"
+        ],
+        "additionalProperties": false,
+        "properties": {
+          "id": {
+            "type": "string",
+            "pattern": "^[a-z0-9-]+$"
+          },
+          "name": {
+            "type": "string"
+          },
+          "role": {
+            "type": "string",
+            "description": "A role id from governance/venture-template/roles/venture-roles.json"
+          },
+          "hats": {
+            "type": "array",
+            "items": {
+              "enum": [
+                "strategy",
+                "products",
+                "marketing-and-sales",
+                "supply-chain",
+                "service-delivery",
+                "customer-service",
+                "human-capital",
+                "it",
+                "finance",
+                "assets",
+                "risk-and-compliance",
+                "external-relationships",
+                "capabilities"
+              ]
+            },
+            "uniqueItems": true,
+            "description": "The functions this person owns (operations/departments.json)"
+          },
+          "founder_file": {
+            "type": "string",
+            "pattern": "^people/founders/[a-z0-9-]+\\.json$"
+          }
+        }
+      }
+    },
+    "founder_agreement": {
+      "type": "string",
+      "description": "The founder agreement, once there is one (governance/founder-agreement.json)"
+    },
+    "updated": {
+      "type": "string",
+      "format": "date"
+    }
+  }
+}

package/schema/port-venture.mjs

@@ -0,0 +1,161 @@
+#!/usr/bin/env node
+// naive port: brings an existing project into a new venture by keeping its files as they are (EE-076).
+// Each file is placed, unchanged, in the package directory its name or folder points to; a code
+// repository or anything that should stay where it is becomes a pointer in knowledge/sources.json;
+// what fits nowhere is left behind, by name, so nothing disappears silently. Migrate (rewriting a
+// project into the Naive convention) is the other way in, and is not this command.
+//
+//   node schema/port-venture.mjs --from <project> --venture <new venture dir>
+//        writes the plan to <venture>/.release/port-plan.json and prints it; changes nothing else
+//   node schema/port-venture.mjs --venture <dir> --apply --confirm port
+//        carries out the plan as it now reads; the founder may first set any item's action to
+//        port, point or leave
+//
+// The project is only ever read. A port never overwrites a file in the venture, refuses a plan
+// whose source files changed since it was written, and records every copy in provenance.jsonl
+// with the source path it was derived from.
+
+import { createHash } from "node:crypto";
+import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { basename, dirname, extname, join, relative, resolve, sep } from "node:path";
+import { record } from "../interface/provenance.mjs";
+import { SECRET } from "./migrate-venture.mjs";
+
+export const PLAN = ".release/port-plan.json";
+const SKIP = new Set([".git", "node_modules", ".next", ".turbo", "dist", "build", ".venv", "__pycache__", ".DS_Store"]);
+const REPO_MARKERS = [".git", "package.json", "Cargo.toml", "go.mod", "pyproject.toml", "Gemfile", "pom.xml"];
+const CODE = new Set([".js", ".mjs", ".cjs", ".ts", ".tsx", ".jsx", ".py", ".rb", ".go", ".rs", ".java", ".kt", ".swift", ".c", ".h", ".cpp", ".cs", ".php", ".sh", ".sql", ".css", ".scss", ".html", ".lock", ".yml", ".yaml", ".toml"]);
+const MAX_BYTES = 5 * 1024 * 1024;
+
+// The first rule whose pattern matches wins: the file name is tried before its folders, so a file
+// says more about itself than the folder it sits in. Patterns match words in lowercase paths.
+const RULES = [
+  [/\b(problem|pain[- ]?points?)\b/, "foundation", "states the problem"],
+  [/\b(icp|personas?|ideal[- ]customer|customer[- ]profile|segments?)\b/, "foundation", "describes the customer"],
+  [/\b(vision|mission|tagline|values|manifesto|one[- ]pager|strategy)\b/, "foundation", "states what the venture is for"],
+  [/\b(interviews?|surveys?|user[- ]research|customer[- ]research|discovery|experiments?|hypothes[ie]s|validation)\b/, "validation", "is evidence about the problem or the solution"],
+  [/\b(investors?|pitch|deck|fundrais\w*|safe|term[- ]sheet|cap[- ]table|data[- ]room)\b/, "investors", "is for or about investors"],
+  [/\b(pricing|prices?|revenue|budget|forecast|runway|financ\w*|p&l|burn|unit[- ]economics|model)\b/, "finance", "is about money the venture plans or earns"],
+  [/\b(brand\w*|marketing|copy|landing|seo|social|launch|blog|newsletter|campaigns?|content|go[- ]to[- ]market|gtm)\b/, "marketing", "is marketing or sales"],
+  [/\b(roadmap|specs?|prd|requirements|features?|product|designs?|ux|ui|wireframes?|mockups?|backlog)\b/, "product", "describes the product"],
+  [/\b(team|hiring|roles?|org[- ]chart|founders?|equity|vesting|people|onboarding|handbook|culture)\b/, "people", "is about the people"],
+  [/\b(customers?|clients?|accounts|crm|leads|pipeline)\b/, "customers", "is about customers"],
+  [/\b(decisions?|adrs?|decision[- ]log)\b/, "decisions", "records decisions"],
+  [/\b(legal|contracts?|agreements?|incorporation|bylaws|operating[- ]agreement|nda|terms|privacy|trademark|ip)\b/, "_private/legal", "is a legal document, kept private so it never reaches a model"],
+];
+const BANK = /\b(bank|transactions?|ledger|payroll|tax(es)?)\b/;
+
+const words = (s) => s.toLowerCase().replace(/[_.]+/g, " ");
+const sha = (f) => createHash("sha256").update(readFileSync(f)).digest("hex");
+const slug = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "project";
+
+/** Where one file goes, or why it stays behind. `rel` is relative to the project root. */
+export function place(rel, bytes) {
+  const name = basename(rel, extname(rel));
+  const ext = extname(rel).toLowerCase();
+  if (bytes > MAX_BYTES) return { action: "leave", reason: `larger than ${MAX_BYTES / 1024 / 1024} MB; point to it instead` };
+  if (CODE.has(ext)) return { action: "leave", reason: "code or configuration: it stays in its repository" };
+  const folders = dirname(rel) === "." ? [] : dirname(rel).split(sep).reverse();
+  for (const [where, confidence] of [[name, "high"], ...folders.map((f) => [f, "low"])]) {
+    if (BANK.test(words(where))) return { action: "leave", reason: "bank and payroll data come from the bank connection, not from files" };
+    const hit = RULES.find(([re]) => re.test(words(where)));
+    if (hit) return { action: "port", to: `${hit[1]}/${basename(rel)}`, function: hit[1].split("/").at(-1), confidence, reason: `${confidence === "high" ? "its name" : `its folder ${where}`} ${hit[2]}` };
+  }
+  if (/^readme$/i.test(name)) return { action: "leave", reason: "the venture has its own AGENTS.md and profile.md; read this to write profile.md" };
+  return { action: "leave", reason: "nothing in its name or folders matches a package; place it by hand or migrate it" };
+}
+
+function walk(root, rel = "", out = { files: [], repos: [], secrets: [] }) {
+  for (const e of readdirSync(join(root, rel), { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+    if (SKIP.has(e.name) || e.isSymbolicLink()) continue;
+    const r = rel ? join(rel, e.name) : e.name;
+    if (e.isDirectory()) {
+      if (REPO_MARKERS.some((m) => existsSync(join(root, r, m)))) out.repos.push(r);
+      else walk(root, r, out);
+    } else if (e.isFile() && SECRET.test(r)) out.secrets.push(r);
+    else if (e.isFile() && !e.name.startsWith(".")) out.files.push(r);
+  }
+  return out;
+}
+
+/** The plan for porting `from` into the venture at `dir`. Reads both, writes neither. */
+export function plan(from, dir) {
+  const src = resolve(from);
+  if (!existsSync(src) || !statSync(src).isDirectory()) throw new Error(`${from} is not a directory`);
+  if (!existsSync(join(dir, "venture.json"))) throw new Error(`${dir} is not a venture: create one first with naive init`);
+  if (resolve(dir).startsWith(src + sep) || resolve(dir) === src) throw new Error("the venture cannot sit inside the project it ports from");
+  const { files, repos, secrets } = walk(src);
+  const items = secrets.map((f) => ({ from: f, action: "leave", reason: "looks like a secret, so it was never opened" }));
+  // The project itself is a repository when it carries a marker at its root: point to it, and still
+  // port its documents.
+  for (const r of REPO_MARKERS.some((m) => existsSync(join(src, m))) ? ["", ...repos] : repos)
+    items.push({ from: r || ".", action: "point", source: slug(r ? basename(r) : basename(src)), reason: "a code repository stays where it is; the venture points to it" });
+  const taken = new Set();
+  for (const f of files) {
+    const p = place(f, statSync(join(src, f)).size);
+    if (p.action === "port") {
+      // Two files with one name in one package: the second keeps its folder name in front.
+      if (taken.has(p.to)) p.to = `${dirname(p.to)}/${slug(basename(dirname(f)))}-${basename(f)}`;
+      if (taken.has(p.to) || existsSync(join(dir, p.to))) Object.assign(p, { action: "leave", reason: `${p.to} already exists in the venture; a port never overwrites` });
+      else taken.add(p.to);
+    }
+    items.push({ from: f, sha256: sha(join(src, f)), ...p });
+  }
+  const count = (a) => items.filter((i) => i.action === a).length;
+  return { from: src, venture: JSON.parse(readFileSync(join(dir, "venture.json"), "utf8")).id, at: new Date().toISOString(),
+    summary: { port: count("port"), point: count("point"), leave: count("leave") }, items };
+}
+
+/** Carries out a plan as the founder left it. Returns what was done. */
+export function apply(dir, p, agent = { kind: "person", via: "cli" }) {
+  const src = p.from;
+  for (const i of p.items.filter((x) => x.action === "port")) {
+    if (!existsSync(join(src, i.from)) || sha(join(src, i.from)) !== i.sha256) throw new Error(`${i.from} changed since the plan was written; write the plan again`);
+    if (existsSync(join(dir, i.to))) throw new Error(`${i.to} already exists in the venture; a port never overwrites`);
+  }
+  const done = { ported: [], pointed: [] };
+  for (const i of p.items.filter((x) => x.action === "port")) {
+    mkdirSync(dirname(join(dir, i.to)), { recursive: true });
+    copyFileSync(join(src, i.from), join(dir, i.to));
+    record(dir, { entity: i.to, activity: "port", agent, derived_from: [`file://${join(src, i.from)}`], note: `ported unchanged: ${i.reason}` });
+    done.ported.push(i.to);
+  }
+  const points = p.items.filter((x) => x.action === "point");
+  if (points.length) {
+    const f = join(dir, "knowledge/sources.json");
+    const map = existsSync(f) ? JSON.parse(readFileSync(f, "utf8")) : { sources: [], records: {} };
+    for (const i of points) {
+      if (map.sources.some((s) => s.id === i.source)) continue;
+      map.sources.push({ id: i.source, connector: "filesystem", writes: "none", root: join(src, i.from === "." ? "" : i.from), note: `ported as a pointer: ${i.reason}` });
+      done.pointed.push(i.source);
+    }
+    mkdirSync(dirname(f), { recursive: true });
+    writeFileSync(f, JSON.stringify(map, null, 2) + "\n");
+    if (done.pointed.length) record(dir, { entity: "knowledge/sources.json", activity: "port", agent, note: `pointers to ${done.pointed.join(", ")}` });
+  }
+  return done;
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const args = process.argv.slice(2);
+  const opt = (k) => { const i = args.indexOf(`--${k}`); return i < 0 ? undefined : args[i + 1]; };
+  const dir = opt("venture");
+  if (!dir) { console.error("usage: node schema/port-venture.mjs --from <project> --venture <dir> | --venture <dir> --apply --confirm port"); process.exit(2); }
+  try {
+    if (args.includes("--apply")) {
+      if (opt("confirm") !== "port") { console.error("type --confirm port to carry out the plan"); process.exit(1); }
+      if (!existsSync(join(dir, PLAN))) { console.error(`no plan at ${join(dir, PLAN)}: run with --from first`); process.exit(1); }
+      const d = apply(dir, JSON.parse(readFileSync(join(dir, PLAN), "utf8")));
+      console.log(`ported ${d.ported.length} files unchanged; pointed to ${d.pointed.length} source${d.pointed.length === 1 ? "" : "s"}`);
+    } else {
+      const from = opt("from");
+      if (!from) { console.error("--from <project> is needed to write a plan"); process.exit(2); }
+      const p = plan(from, dir);
+      mkdirSync(join(dir, ".release"), { recursive: true });
+      writeFileSync(join(dir, PLAN), JSON.stringify(p, null, 2) + "\n");
+      for (const i of p.items) console.log(`${i.action.padEnd(5)}  ${i.from}${i.to ? `  ->  ${i.to}` : i.source ? `  ->  source ${i.source}` : ""}   (${i.reason})`);
+      console.log(`\n${p.summary.port} to port, ${p.summary.point} to point to, ${p.summary.leave} left behind. Nothing has changed yet.`);
+      console.log(`Read ${relative(process.cwd(), join(dir, PLAN))}, set any item's action to port, point or leave, then run with --apply --confirm port.`);
+    }
+  } catch (e) { console.error(e.message); process.exit(1); }
+}