naive-framework 0.0.0-stage → 0.1.0

package/schema/docket.mjs

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+// The decision docket across functions (EE-075): which function of the venture needs the founder's
+// attention most right now, and which of its decisions come first. Decisions are ranked inside each
+// function, and functions are ranked against each other, so the answer can move many times in a day as
+// decisions are settled.
+//
+//   node schema/docket.mjs <venture dir> [--json]
+//   node schema/docket.mjs <venture dir> --replay [--steps <n>]   settles the top decision, again and again, in a copy
+//
+// The model, in code (no model call):
+//   own(d)    a decision's own weight: 10 for being open, plus ownScore in schema/decisions.mjs (deadline,
+//             staleness, what it unlocks, the foundation, a draft to approve, outcomes to test)
+//   value(d)  own(d) plus the own weight of every decision it holds, transitively. A fail-closed gate carries
+//             the weight of everything waiting behind it, so one decision can outweigh whole functions.
+//   attention(f)  the values of the decisions in f the founder can act on now, highest first, each worth half
+//             the one before (v1 + v2/2 + v4/4...). A founder settles one decision at a time, so breadth adds
+//             urgency but never outweighs one heavy decision. Each held decision counts once, under its gate.
+//   dominant  a decision whose value is more than the attention of every other function put together.
+//
+// Function: the core package whose record the decision decides (schema/decision-analytics.mjs).
+
+import { spawnSync } from "node:child_process";
+import { cpSync, mkdtempSync, mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, join } from "node:path";
+import { decisions, ownScore } from "./decisions.mjs";
+import { analytics } from "./decision-analytics.mjs";
+import { PACKAGES } from "./packages.mjs";
+
+const ACTIONABLE = new Set(["now", "overdue", "stale"]);
+const OPEN = new Set(["now", "overdue", "stale", "waiting"]);
+const BASE = 10;
+
+export function docket(dir, now = Date.parse(process.env.DECISIONS_NOW ?? "") || Date.now(), { set_aside = new Set() } = {}) {
+  const r = decisions(dir, now);
+  const fnOf = new Map(analytics(dir, now).decisions.map((x) => [x.id, { id: x.function_id, title: x.function }]));
+  const ds = r.decisions.filter((d) => d.source !== "root" && !set_aside.has(d.id)).map((d) => ({ ...d, function: fnOf.get(d.id) }));
+  return { venture: r.venture, ...rankDocket(ds, r.phase, now) };
+}
+
+/** The ranking itself, over decisions as decisions.mjs resolves them, each with its function ({id, title}).
+ *  Pure, so scenarios can be ranked without a venture on disk (schema/docket-eval.mjs). */
+export function rankDocket(all, phase, now = Date.now()) {
+  const ds = all.filter((d) => OPEN.has(d.render));
+  const own = new Map(ds.map((d) => { const o = ownScore(d, phase, now); return [d.id, { score: BASE + o.score, why: o.why }]; }));
+  const heldBy = new Map();
+  for (const d of ds) if (d.held_by) heldBy.set(d.held_by, [...(heldBy.get(d.held_by) ?? []), d.id]);
+  const holds = (id, seen = new Set()) => { for (const x of heldBy.get(id) ?? []) if (!seen.has(x)) { seen.add(x); holds(x, seen); } return seen; };
+
+  const rows = ds.filter((d) => ACTIONABLE.has(d.render)).map((d) => {
+    const held = [...holds(d.id)];
+    const value = own.get(d.id).score + held.reduce((s, x) => s + (own.get(x)?.score ?? 0), 0);
+    const fn = d.function ?? { id: "venture", title: "Venture" };
+    return { id: d.id, question: d.question, function: fn.title, function_id: fn.id, render: d.render, own: own.get(d.id).score, value,
+      holds: held, why: [...own.get(d.id).why, ...(held.length ? [`holds ${held.length} decision${held.length > 1 ? "s" : ""}: ${held.join(", ")}`] : [])], action: d.action ?? null };
+  });
+  const functions = [...new Set(rows.map((x) => x.function_id))].map((id) => {
+    const xs = rows.filter((x) => x.function_id === id).sort((a, b) => b.value - a.value || a.id.localeCompare(b.id));
+    return { id, function: xs[0].function, attention: Math.round(xs.reduce((s, x, i) => s + x.value / 2 ** i, 0)), decisions: xs };
+  // A tie goes to the function that fits the phase better (schema/packages.json, base), not to the alphabet.
+  }).sort((a, b) => b.attention - a.attention || (PACKAGES.core[b.id]?.base?.[phase] ?? 0) - (PACKAGES.core[a.id]?.base?.[phase] ?? 0) || a.id.localeCompare(b.id));
+  const total = functions.reduce((s, f) => s + f.attention, 0);
+  for (const f of functions) {
+    f.share = total ? Math.round((f.attention / total) * 100) / 100 : 0;
+    for (const d of f.decisions) d.dominant = d.value > total - f.attention && functions.length > 1;
+  }
+  const top = functions[0];
+  return {
+    phase, at: new Date(now).toISOString(), total,
+    next: top ? { function: top.function, function_id: top.id, decision: top.decisions[0].id, question: top.decisions[0].question, value: top.decisions[0].value,
+      dominant: top.decisions[0].dominant, why: top.decisions[0].why, action: top.decisions[0].action } : null,
+    functions,
+  };
+}
+
+// Settles one decision the way a founder would, through the CLI, with its proposed wording.
+function settle(ws, venture, d) {
+  const cli = (...a) => spawnSync("node", [new URL("../interface/cli/mentura.mjs", import.meta.url).pathname, ...a], { env: { ...process.env, MENTURA_WORKSPACE: ws }, encoding: "utf8" });
+  const a = d.action;
+  if (!a) return false;
+  const p = a.kind === "decide" ? cli("decide", d.id, "--venture", venture, "--by", "Founder (replay)", "--answer", "Settled in the replay", "--confirm", a.confirm)
+    : a.kind === "accept" ? cli("accept", a.route, "--venture", venture, "--confirm", a.confirm)
+    : a.kind === "confirm" ? cli("confirm", a.statement, "--venture", venture, "--confirm", a.confirm) : null;
+  return p?.status === 0;
+}
+
+/** The founder's day, replayed on a copy: settle the top decision, recompute, and record which function
+ *  leads after each step. A decision only the founder can write (a statement to draft) can't be settled
+ *  by a replay, so it is set aside for the rest of the day, as a founder who leaves it for tomorrow would. */
+export function replay(dir, steps = 20) {
+  const ws = mkdtempSync(join(tmpdir(), "docket-replay-"));
+  const venture = basename(dir);
+  const copy = join(ws, "ventures", venture);
+  mkdirSync(join(ws, "ventures"), { recursive: true });
+  cpSync(dir, copy, { recursive: true });
+  const skipped = new Set();
+  const timeline = [];
+  for (let i = 0; i < steps; i++) {
+    const k = docket(copy, undefined, { set_aside: skipped });
+    const top = k.functions[0];
+    if (!top) break;
+    const pick = { f: top, d: top.decisions[0] };
+    const ok = settle(ws, venture, pick.d);
+    timeline.push({ step: i + 1, leading: pick.f.function, attention: Object.fromEntries(k.functions.map((f) => [f.function, f.attention])),
+      decision: pick.d.id, value: pick.d.value, dominant: pick.d.dominant, settled: ok });
+    if (!ok) skipped.add(pick.d.id);
+  }
+  const leaders = timeline.filter((t) => t.settled).map((t) => t.leading);
+  return { venture, steps: timeline.length, settled: timeline.filter((t) => t.settled).length,
+    leader_changes: leaders.filter((l, i) => i && l !== leaders[i - 1]).length, timeline };
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const dir = process.argv[2];
+  if (!dir) { console.error("usage: node schema/docket.mjs <venture dir> [--json] [--replay [--steps <n>]]"); process.exit(2); }
+  const i = process.argv.indexOf("--steps");
+  if (process.argv.includes("--replay")) {
+    const r = replay(dir, i >= 0 ? Number(process.argv[i + 1]) : 20);
+    if (process.argv.includes("--json")) console.log(JSON.stringify(r, null, 2));
+    else {
+      for (const t of r.timeline) console.log(`${String(t.step).padStart(2)}. ${t.leading.padEnd(12)} ${t.decision}${t.dominant ? " (outweighs every other function)" : ""}  value ${t.value}${t.settled ? "" : "  [the founder writes this one: set aside]"}   ${Object.entries(t.attention).map(([f, a]) => `${f} ${a}`).join(" · ")}`);
+      console.log(`\n${r.settled} settled; the leading function changed ${r.leader_changes} times`);
+    }
+  } else {
+    const k = docket(dir);
+    if (process.argv.includes("--json")) console.log(JSON.stringify(k, null, 2));
+    else {
+      console.log(`${k.venture} (${k.phase}): next is ${k.next ? `${k.next.decision} in ${k.next.function}${k.next.dominant ? ", which outweighs every other function" : ""}` : "nothing"}`);
+      for (const f of k.functions) {
+        console.log(`\n${f.function}: attention ${f.attention} (${Math.round(f.share * 100)}%)`);
+        for (const d of f.decisions) console.log(`  ${String(d.value).padStart(4)}  ${d.id}${d.dominant ? "  [dominant]" : ""}: ${d.why.join("; ")}`);
+      }
+    }
+  }
+}

package/schema/eval-suite.schema.json

@@ -0,0 +1,45 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "eval-suite.schema.json",
+  "title": "Eval suite",
+  "description": "A set of evals for a skill, a product or the agent environment (EE-017): prompts with the expected behaviour and assertions. A run of a suite writes evidence (evidence.schema.json). Fits the existing evidence/evals/*.json files.",
+  "type": "object",
+  "required": ["evals"],
+  "properties": {
+    "skill_name": { "type": "string" },
+    "subject": { "type": "string", "description": "Product or skill id the suite tests, when not a skill" },
+    "harness_version": { "type": "string", "description": "Version of the suite (legacy name)" },
+    "description": { "type": "string" },
+    "evals": {
+      "type": "array", "minItems": 1,
+      "items": {
+        "type": "object",
+        "required": ["id", "prompt", "expected_output"],
+        "properties": {
+          "id": { "type": "integer" },
+          "eval_name": { "type": "string" },
+          "prompt": { "type": "string" },
+          "expected_output": { "type": "string" },
+          "files": { "type": "array", "items": { "type": "string" } },
+          "systems_invoked": { "type": "array", "items": { "type": "string" } },
+          "handoff_files_touched": { "type": "array", "items": { "type": "string" } },
+          "assertions": {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "required": ["name", "check"],
+              "properties": {
+                "name": { "type": "string" },
+                "check": { "type": "string" },
+                "command": { "type": "string", "description": "When set, the assertion is programmatic: the command decides it" }
+              },
+              "additionalProperties": false
+            }
+          }
+        },
+        "additionalProperties": false
+      }
+    }
+  },
+  "additionalProperties": false
+}

package/schema/evidence.schema.json

@@ -0,0 +1,110 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "evidence.schema.json",
+  "title": "Evidence",
+  "description": "The result of one run of a check or eval, stored at <venture>/evidence/results/<id>.json (EE-017). It names what was checked, at which version, each assertion's outcome and the output that shows it. Results are append-only: a new run writes a new file. Handoffs point at results to prove their done-criteria.",
+  "type": "object",
+  "required": [
+    "id",
+    "subject",
+    "ran_at",
+    "runner",
+    "results",
+    "passed"
+  ],
+  "properties": {
+    "id": {
+      "type": "string",
+      "pattern": "^[a-z0-9-]+$"
+    },
+    "subject": {
+      "type": "object",
+      "required": [
+        "kind",
+        "id"
+      ],
+      "properties": {
+        "kind": {
+          "enum": [
+            "handoff",
+            "product",
+            "skill",
+            "venture",
+            "suite"
+          ]
+        },
+        "id": {
+          "type": "string"
+        },
+        "version": {
+          "type": "string",
+          "description": "Commit, tag or version the run checked"
+        }
+      },
+      "additionalProperties": false
+    },
+    "suite": {
+      "type": "string",
+      "description": "Path to the eval suite, when the run came from one"
+    },
+    "ran_at": {
+      "type": "string",
+      "format": "date-time"
+    },
+    "runner": {
+      "type": "string",
+      "description": "Who or what ran it: a CI job, a session id, a role"
+    },
+    "results": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "required": [
+          "criterion",
+          "kind",
+          "passed"
+        ],
+        "properties": {
+          "criterion": {
+            "type": "string",
+            "description": "A handoff done-criterion id, or an eval assertion name"
+          },
+          "kind": {
+            "enum": [
+              "conformance",
+              "self-proof",
+              "review",
+              "judged"
+            ],
+            "description": "judged: scored by a model against a rubric, which counts as evidence only for review and evals, never conformance"
+          },
+          "passed": {
+            "type": "boolean"
+          },
+          "command": {
+            "type": "string"
+          },
+          "output": {
+            "type": "string",
+            "description": "The output, trimmed to what shows the outcome"
+          },
+          "artifact": {
+            "type": "string",
+            "description": "Path or link to a screenshot, log or report"
+          },
+          "by": {
+            "type": "string",
+            "description": "For review results: the role that judged it, which must be the criterion's reviewer and not the handoff's holder"
+          }
+        },
+        "additionalProperties": false
+      }
+    },
+    "passed": {
+      "type": "boolean",
+      "description": "True only when every result passed"
+    }
+  },
+  "additionalProperties": false
+}

package/schema/examples/migrate/agent.mjs

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+// A stand-in for the migrate agent in tests (MENTURA_AGENT_CMD="node schema/examples/migrate/agent.mjs"):
+// reads the prompt on stdin and answers the way claude -p --output-format json does, with one product
+// record from the source's notes/plan.md and everything else left behind.
+let prompt = "";
+for await (const c of process.stdin) prompt += c;
+const files = JSON.parse(prompt.slice(prompt.lastIndexOf("Files: ") + 7));
+const answer = {
+  items: "notes/plan.md" in files ? [{ route: "product/kettle", from: ["notes/plan.md"], record: { id: "kettle", name: "Kettle", description: files["notes/plan.md"].split("\n").filter((l) => l && !l.startsWith("#"))[0] }, reshaping: "the plan's first line became the product description", confidence: 0.8 }] : [],
+  left_behind: Object.keys(files).filter((f) => f !== "notes/plan.md").map((f) => ({ from: f, why: "no record says what this file says" })),
+};
+console.log(JSON.stringify({ type: "result", is_error: false, result: JSON.stringify(answer) }));

package/schema/examples/workspace/ventures/studio/accounts/bakery/account.json

@@ -0,0 +1,18 @@
+{
+  "id": "bakery",
+  "name": "Corner Bakery",
+  "relationship": "client",
+  "status": "active",
+  "opened": "2026-09-01",
+  "products": [
+    "brand-kit"
+  ],
+  "layers": {
+    "knowledge": {
+      "location": "knowledge/"
+    },
+    "operations": {
+      "location": "handoffs/"
+    }
+  }
+}

package/schema/examples/workspace/ventures/studio/print/venture.json

@@ -0,0 +1,37 @@
+{
+  "id": "studio-print",
+  "name": "Alex Studio print line",
+  "parent": "studio",
+  "phase": "validation",
+  "ambition": "lifestyle",
+  "core": {
+    "promise": "Restaurant print that matches the brand, delivered in two days",
+    "promised_to": "Alex Studio's restaurant clients",
+    "must_not": "Print that drifts from the brand system",
+    "competence": "Print-ready files from the brand system"
+  },
+  "owner": "self",
+  "status": "active",
+  "profile": "profile.md",
+  "layers": {
+    "purpose": {
+      "location": "purpose/"
+    },
+    "knowledge": {
+      "location": "knowledge/"
+    },
+    "operations": false,
+    "evidence": false
+  },
+  "links": [
+    {
+      "to": "studio",
+      "access": "shares-with",
+      "carries": [
+        "sales",
+        "costs"
+      ],
+      "border": "open"
+    }
+  ]
+}

package/schema/examples/workspace/ventures/studio/products/brand-care.json

@@ -0,0 +1,19 @@
+{
+  "id": "brand-care",
+  "name": "Brand Care",
+  "description": "Monthly updates to menus, seasonal signage and social posts in the restaurant's brand.",
+  "market": {
+    "customer": "b2b",
+    "segment": "independent restaurants",
+    "geography": "US-TX",
+    "vertical": true
+  },
+  "job": "Keep the brand current without hiring a designer",
+  "technology": "design service",
+  "offering": "service",
+  "business_model": [
+    "subscription"
+  ],
+  "allowed_from": "beachhead",
+  "status": "building"
+}

package/schema/examples/workspace/ventures/studio/products/brand-kit.json

@@ -0,0 +1,23 @@
+{
+  "id": "brand-kit",
+  "name": "Brand Kit",
+  "description": "Logo, menu, signage and site templates built in one week for a restaurant about to open.",
+  "market": {
+    "customer": "b2b",
+    "segment": "restaurants about to open",
+    "geography": "US-TX",
+    "vertical": true
+  },
+  "job": "Open with a menu, sign and site that match",
+  "technology": "design service plus templates",
+  "offering": "service",
+  "business_model": [
+    "fee-for-service",
+    "add-on"
+  ],
+  "allowed_from": "validation",
+  "flows_to": [
+    "brand-care"
+  ],
+  "status": "live"
+}

package/schema/examples/workspace/ventures/studio/provenance.jsonl

@@ -0,0 +1,3 @@
+{"at":"2026-10-27T21:01:55.765Z","entity":"accounts/bakery/account.json","route":"purpose/account","activity":"baseline","agent":{"kind":"agent","via":"cli","id":"builder","harness":"Claude Code"},"note":"existed before the provenance log; its history before this is in git","sha256":"370c11ef6365be264e0ea7799f261ff5dc058a6860b34fb3066261324b160d22","prev":"genesis","hash":"faa7d64c6c62a66e8e33fb27368e8555afd6cdc9cfe42d6ab0d44e7eff3adf4a"}
+{"at":"2026-10-27T21:01:55.767Z","entity":"products/brand-care.json","route":"purpose/product","activity":"baseline","agent":{"kind":"agent","via":"cli","id":"builder","harness":"Claude Code"},"note":"existed before the provenance log; its history before this is in git","sha256":"bd1540d50f1cc51fcc7b071d47ee1287ab63bb0cf932723f092ddac9a392032f","prev":"faa7d64c6c62a66e8e33fb27368e8555afd6cdc9cfe42d6ab0d44e7eff3adf4a","hash":"db84fc785cb173ce50b69751fc92582be55d2a2eb03f901ed14606ce317ddf4d"}
+{"at":"2026-10-27T21:01:55.767Z","entity":"products/brand-kit.json","route":"purpose/product","activity":"baseline","agent":{"kind":"agent","via":"cli","id":"builder","harness":"Claude Code"},"note":"existed before the provenance log; its history before this is in git","sha256":"aea7058e9feb3f722d06e36f184352e84c7430a08dab76e1fd0aa92d6d31bae2","prev":"db84fc785cb173ce50b69751fc92582be55d2a2eb03f901ed14606ce317ddf4d","hash":"26b51e9a180e596a787aa5c8909d8abf634e5b5be88d0f45abd3554985a65467"}

package/schema/examples/workspace/ventures/studio/venture.json

@@ -0,0 +1,43 @@
+{
+  "id": "studio",
+  "name": "Alex Studio",
+  "parent": null,
+  "phase": "beachhead",
+  "ambition": "managed-growth",
+  "form": {
+    "legal_form": "llc",
+    "funding": "bootstrapped"
+  },
+  "industry": {
+    "system": "naics",
+    "code": "541430",
+    "label": "Graphic Design Services"
+  },
+  "core": {
+    "promise": "A brand that looks established on day one",
+    "promised_to": "Independent restaurant owners",
+    "must_not": "Templates passed off as custom work",
+    "competence": "Fast brand systems built from a restaurant's own story"
+  },
+  "owner": "self",
+  "status": "active",
+  "opened": "2025-03-01",
+  "profile": "profile.md",
+  "layers": {
+    "purpose": {
+      "location": "purpose/"
+    },
+    "knowledge": {
+      "location": "knowledge/"
+    },
+    "operations": {
+      "location": "operations/"
+    },
+    "evidence": {
+      "location": "evidence/"
+    },
+    "governance": {
+      "location": "governance/"
+    }
+  }
+}

package/schema/examples/workspace/ventures/tandem/evidence/README.md

@@ -0,0 +1,3 @@
+# evidence
+
+Did it work: reviews, evals and metrics.

package/schema/examples/workspace/ventures/tandem/governance/README.md

@@ -0,0 +1,3 @@
+# governance
+
+Who may decide what: roles and decision rights.

package/schema/examples/workspace/ventures/tandem/governance/agreements/dee-fast.md

@@ -0,0 +1,3 @@
+# Advisor agreement: Dee Park (example)
+
+Fictional example. Based on the Founder Institute's FAST template: standard advisor, 0.5% of common over 24 months.

package/schema/examples/workspace/ventures/tandem/governance/board.json

@@ -0,0 +1,51 @@
+{
+  "updated": "2026-10-01",
+  "boards": [
+    {
+      "id": "directors",
+      "kind": "formal",
+      "formed": "2026-09-15",
+      "meets": "every-6-weeks",
+      "seats": [
+        {
+          "id": "seat-common-1",
+          "person": "Ana Reyes",
+          "type": "founder",
+          "appointed_by": "common"
+        },
+        {
+          "id": "seat-preferred",
+          "person": "Jo Lark",
+          "type": "investor",
+          "appointed_by": "series-seed"
+        },
+        {
+          "id": "seat-independent",
+          "person": null,
+          "type": "independent",
+          "appointed_by": "board"
+        }
+      ],
+      "reserved_matters": [
+        "issue or reclassify shares",
+        "approve the annual budget",
+        "hire or remove the CEO",
+        "sell, merge or wind down the company",
+        "take on debt over 100,000 USD"
+      ]
+    },
+    {
+      "id": "advisors",
+      "kind": "advisory",
+      "meets": "quarterly",
+      "seats": [
+        {
+          "id": "seat-dee",
+          "person": "Dee Park",
+          "type": "advisor",
+          "appointed_by": "board"
+        }
+      ]
+    }
+  ]
+}

package/schema/examples/workspace/ventures/tandem/governance/departments/finance/charter.md

@@ -0,0 +1,5 @@
+# Finance and accounting: charter
+
+Holds: Spending authority, controls and audit.
+
+APQC 9.0 Manage Financial Resources; value chain: support (firm infrastructure).

package/schema/examples/workspace/ventures/tandem/governance/departments/finance/department.json

@@ -0,0 +1,5 @@
+{
+  "department": "finance",
+  "value_chain": "support",
+  "apqc": "9.0"
+}

package/schema/examples/workspace/ventures/tandem/governance/departments/primary/marketing-and-sales/charter.md

@@ -0,0 +1,5 @@
+# Marketing and sales: charter
+
+Holds: Brand guidelines and the publication policy.
+
+APQC 3.0 Market and Sell Products and Services; value chain: primary (marketing and sales).

package/schema/examples/workspace/ventures/tandem/governance/departments/primary/marketing-and-sales/department.json

@@ -0,0 +1,5 @@
+{
+  "department": "marketing-and-sales",
+  "value_chain": "primary",
+  "apqc": "3.0"
+}

package/schema/examples/workspace/ventures/tandem/governance/exit.json

@@ -0,0 +1,33 @@
+{
+  "paths": [
+    {
+      "kind": "acquisition",
+      "stance": "preferred",
+      "note": "Vertical software buyers consolidate small-business tools"
+    },
+    {
+      "kind": "ipo",
+      "stance": "open"
+    },
+    {
+      "kind": "wind-down",
+      "stance": "open",
+      "note": "If the seed runs out without traction"
+    }
+  ],
+  "scenarios": [
+    {
+      "id": "soft-landing",
+      "value": 3000000,
+      "note": "Acqui-hire"
+    },
+    {
+      "id": "base",
+      "value": 40000000
+    },
+    {
+      "id": "strong",
+      "value": 150000000
+    }
+  ]
+}

package/schema/examples/workspace/ventures/tandem/governance/founder-agreement.json

@@ -0,0 +1,24 @@
+{
+  "signed": "2026-03-02",
+  "document": "governance/founder-agreement.md",
+  "founders": [
+    {
+      "holder": "ana",
+      "role": "CEO",
+      "commitment": "full-time",
+      "ip_assigned": true
+    },
+    {
+      "holder": "ben",
+      "role": "CTO",
+      "commitment": "full-time",
+      "ip_assigned": true
+    }
+  ],
+  "departure": {
+    "good_leaver": "Keeps vested shares; the company may buy unvested shares back at cost",
+    "bad_leaver": "Keeps vested shares; unvested shares return at cost",
+    "buyback": "unvested-at-cost"
+  },
+  "deadlock": "Founders talk it through with the independent director; if still split, the CEO decides product and the CTO decides engineering"
+}

package/schema/examples/workspace/ventures/tandem/governance/founder-agreement.md

@@ -0,0 +1,3 @@
+# Founder agreement (example)
+
+Fictional example for the schema. A real agreement is drafted with counsel; this file would hold its text or point to the signed copy.