naive-framework 0.0.0-stage → 0.1.0

package/schema/examples/workspace/ventures/tandem/purpose/validation/problem.json

@@ -0,0 +1,74 @@
+{
+  "venture": "tandem",
+  "updated": "2026-10-27",
+  "statement": "Running bookings, stock and payroll in separate tools eats five to ten hours a week that the owner should spend serving customers",
+  "segment": "Owners of two-to-ten-person service shops (salons, repair shops, studios) in the US",
+  "frequency": "Weekly, at payroll and stock counts; daily for bookings",
+  "cost": "Five to ten owner hours a week, plus subscriptions to three or more tools",
+  "workarounds": [
+    "A booking app, a spreadsheet for stock and a payroll service, reconciled by hand",
+    "Paper diaries in the smallest shops"
+  ],
+  "evidence": [
+    {
+      "id": "tool-spend",
+      "kind": "behavior",
+      "summary": "9 of 12 owners already pay for three or more separate tools for bookings, stock and payroll",
+      "source": {
+        "title": "Problem interviews, September 2026",
+        "path": "knowledge/research/problem-interviews-2026-09.md"
+      },
+      "audience": "target",
+      "sample": {
+        "n": 12,
+        "types": [
+          "salon",
+          "repair",
+          "studio"
+        ]
+      },
+      "collected": "2026-09-20"
+    },
+    {
+      "id": "admin-hours",
+      "kind": "stated",
+      "summary": "Owners described last week's admin in detail: a median of 6 hours reconciling the three tools",
+      "source": {
+        "title": "Problem interviews, September 2026",
+        "path": "knowledge/research/problem-interviews-2026-09.md"
+      },
+      "audience": "target",
+      "sample": {
+        "n": 12,
+        "types": [
+          "salon",
+          "repair",
+          "studio"
+        ]
+      },
+      "specificity": "specific",
+      "collected": "2026-09-20"
+    },
+    {
+      "id": "friends-praise",
+      "kind": "opinion",
+      "summary": "Six friends who run no shop said the idea sounds useful",
+      "source": {
+        "title": "Feedback from friends, August 2026",
+        "path": "knowledge/research/friends-feedback-2026-08.md"
+      },
+      "audience": "wrong",
+      "sample": {
+        "n": 6
+      },
+      "specificity": "general",
+      "collected": "2026-08-10"
+    }
+  ],
+  "probability": {
+    "p": 0.75,
+    "by": "owner",
+    "scored": "2026-10-27",
+    "note": "Example value; Jev scores it once the scorer runs"
+  }
+}

package/schema/examples/workspace/ventures/tandem/purpose/validation/product-market-fit.json

@@ -0,0 +1,66 @@
+{
+  "venture": "tandem",
+  "updated": "2026-10-27",
+  "product": "shop-app",
+  "segment": "Two-to-ten-person service shops",
+  "retention": {
+    "period": "week",
+    "cohorts": [
+      {
+        "start": "2026-07-06",
+        "size": 11,
+        "active": [
+          11,
+          10,
+          9,
+          9,
+          9,
+          9,
+          9
+        ]
+      }
+    ]
+  },
+  "ellis": {
+    "asked": 34,
+    "very_disappointed": 16,
+    "collected": "2026-10-15"
+  },
+  "evidence": [
+    {
+      "id": "pilot-retention",
+      "kind": "behavior",
+      "summary": "9 of 11 shops still active weekly after seven weeks; the curve is flat from week three",
+      "source": {
+        "title": "Pilot, July to October 2026",
+        "path": "knowledge/research/pilot-2026-10.md"
+      },
+      "audience": "target",
+      "sample": {
+        "n": 11
+      },
+      "collected": "2026-10-20"
+    },
+    {
+      "id": "ellis-survey",
+      "kind": "stated",
+      "summary": "16 of 34 active users (47%) would be very disappointed without the app",
+      "source": {
+        "title": "Pilot, July to October 2026",
+        "path": "knowledge/research/pilot-2026-10.md"
+      },
+      "audience": "target",
+      "sample": {
+        "n": 34
+      },
+      "specificity": "specific",
+      "collected": "2026-10-15"
+    }
+  ],
+  "probability": {
+    "p": 0.6,
+    "by": "owner",
+    "scored": "2026-10-27",
+    "note": "Example value"
+  }
+}

package/schema/examples/workspace/ventures/tandem/purpose/validation/solution.json

@@ -0,0 +1,33 @@
+{
+  "venture": "tandem",
+  "updated": "2026-10-27",
+  "statement": "One phone app that keeps bookings, stock and payroll in one record, so nothing needs reconciling",
+  "product": "shop-app",
+  "alternatives": [
+    "Three separate tools reconciled by hand",
+    "Paper diaries"
+  ],
+  "difference": "No weekly reconciliation; one subscription instead of three",
+  "evidence": [
+    {
+      "id": "switched",
+      "kind": "behavior",
+      "summary": "9 of 11 pilot shops stopped using their separate booking tool within a month",
+      "source": {
+        "title": "Pilot, July to October 2026",
+        "path": "knowledge/research/pilot-2026-10.md"
+      },
+      "audience": "target",
+      "sample": {
+        "n": 11
+      },
+      "collected": "2026-10-20"
+    }
+  ],
+  "probability": {
+    "p": 0.7,
+    "by": "owner",
+    "scored": "2026-10-27",
+    "note": "Example value"
+  }
+}

package/schema/examples/workspace/ventures/tandem/purpose/validation/team.json

@@ -0,0 +1,52 @@
+{
+  "venture": "tandem",
+  "updated": "2026-10-27",
+  "needed": [
+    {
+      "skill": "mobile engineering",
+      "by_phase": "validation"
+    },
+    {
+      "skill": "small-business sales",
+      "by_phase": "validation"
+    },
+    {
+      "skill": "payroll compliance",
+      "by_phase": "beachhead",
+      "why": "Payroll rules differ by state"
+    }
+  ],
+  "held": [
+    {
+      "skill": "mobile engineering",
+      "by": "founder"
+    },
+    {
+      "skill": "small-business sales",
+      "by": "founder"
+    }
+  ],
+  "cofounder_sought": false,
+  "evidence": [
+    {
+      "id": "shipped-pilot",
+      "kind": "behavior",
+      "summary": "The two founders built and sold the pilot without outside help",
+      "source": {
+        "title": "Pilot, July to October 2026",
+        "path": "knowledge/research/pilot-2026-10.md"
+      },
+      "audience": "target",
+      "sample": {
+        "n": 11
+      },
+      "collected": "2026-10-20"
+    }
+  ],
+  "probability": {
+    "p": 0.6,
+    "by": "owner",
+    "scored": "2026-10-27",
+    "note": "Example value"
+  }
+}

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

@@ -0,0 +1,79 @@
+{
+  "id": "tandem",
+  "name": "Tandem",
+  "parent": null,
+  "phase": "validation",
+  "form": {
+    "legal_form": "c-corp",
+    "funding": "venture-capital"
+  },
+  "core": {
+    "promise": "Two people can run a shop's bookings, stock and payroll from one phone",
+    "promised_to": "Owners of two-to-ten-person service shops",
+    "must_not": "Lock a shop's records into a format it cannot export",
+    "competence": "Turning small-shop paperwork into one mobile workflow"
+  },
+  "owner": "shared",
+  "status": "active",
+  "profile": "profile.md",
+  "layers": {
+    "purpose": {
+      "location": "purpose/"
+    },
+    "knowledge": {
+      "location": "knowledge/"
+    },
+    "operations": {
+      "location": "operations/"
+    },
+    "evidence": {
+      "location": "evidence/"
+    },
+    "governance": {
+      "location": "governance/"
+    }
+  },
+  "repos": [
+    {
+      "id": "tandem-app",
+      "url": "https://example.com/tandem/tandem-app",
+      "products": [
+        "shop-app"
+      ]
+    }
+  ],
+  "ambition": "aggressive-growth",
+  "industry": {
+    "system": "naics",
+    "code": "513210",
+    "label": "Software Publishers"
+  },
+  "opened": "2026-03-02",
+  "members": [
+    {
+      "role": "founder",
+      "kind": "person"
+    },
+    {
+      "role": "founder",
+      "kind": "person"
+    },
+    {
+      "role": "builder",
+      "kind": "agent",
+      "tools": [
+        "claude-code"
+      ]
+    }
+  ],
+  "regulation": {
+    "exposure": "some",
+    "regimes": [
+      "GDPR"
+    ]
+  },
+  "departments": [
+    "marketing-and-sales",
+    "finance"
+  ]
+}

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

@@ -0,0 +1,21 @@
+{
+  "id": "woodworking",
+  "name": "Woodworking",
+  "parent": null,
+  "phase": "discovery",
+  "ambition": "hobby",
+  "form": {
+    "legal_form": "none"
+  },
+  "owner": "self",
+  "status": "active",
+  "profile": "profile.md",
+  "layers": {
+    "purpose": false,
+    "knowledge": {
+      "location": "knowledge/"
+    },
+    "operations": false,
+    "evidence": false
+  }
+}

package/schema/examples/workspace/workspace.json

@@ -0,0 +1,8 @@
+{
+  "schema": "everything-ecosystem",
+  "schema_version": "0.5.0",
+  "ventures": [
+    "ventures/"
+  ],
+  "code": "code/"
+}

package/schema/exit.schema.json

@@ -0,0 +1,74 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "exit.schema.json",
+  "title": "Exit",
+  "description": "How the venture might end and what each owner would get, at <venture>/governance/exit.json (EE-022): the exit paths it keeps open and the sale values to model. Payouts are never typed here: schema/payouts.mjs computes them from ownership.json for each scenario.",
+  "type": "object",
+  "required": [
+    "paths"
+  ],
+  "additionalProperties": false,
+  "properties": {
+    "paths": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "required": [
+          "kind",
+          "stance"
+        ],
+        "additionalProperties": false,
+        "properties": {
+          "kind": {
+            "enum": [
+              "acquisition",
+              "ipo",
+              "secondary-sale",
+              "merger",
+              "management-buyout",
+              "wind-down",
+              "hold"
+            ],
+            "description": "hold: no exit, the owners keep it"
+          },
+          "stance": {
+            "enum": [
+              "preferred",
+              "open",
+              "ruled-out"
+            ]
+          },
+          "note": {
+            "type": "string"
+          }
+        }
+      }
+    },
+    "scenarios": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": [
+          "id",
+          "value"
+        ],
+        "additionalProperties": false,
+        "properties": {
+          "id": {
+            "type": "string",
+            "pattern": "^[a-z0-9-]+$"
+          },
+          "value": {
+            "type": "number",
+            "minimum": 0,
+            "description": "Proceeds to the owners after debts and costs"
+          },
+          "note": {
+            "type": "string"
+          }
+        }
+      }
+    }
+  }
+}

package/schema/foundation.mjs

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+// Reports a venture's strategic foundation (EE-051, EE-052): for each question of the Five Ws and How plus
+// whether (purpose/strategic-foundation.json), the record attributes that answer it, and whether
+// each is confirmed, drafted by an agent, waiting as a draft, or missing. This is what a founder
+// keeps in front of them; a platform renders it always visible. Behaviors:
+// purpose/kits/validation/features/strategic-foundation.feature.
+//
+//   node schema/foundation.mjs <venture dir> [--json]
+//
+// Status: confirmed (the last write was a person's, or a person accepted it), agent (an agent
+//   wrote it and no person has confirmed it), draft (a draft waits in _drafts/), missing, planned
+//   (no record type yet). A statement an agent drafted is not the founder's until confirmed.
+// Exit 1 when the frame names a record type the data model lacks, or an ICP names a problem form
+// the problem record lacks.
+
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+const repo = new URL("..", import.meta.url).pathname;
+const load = (f) => JSON.parse(readFileSync(f, "utf8"));
+export const FRAME = load(join(repo, "purpose/strategic-foundation.json"));
+const MODEL = load(join(repo, "schema/data-model.json"));
+
+const get = (o, path) => path.split(".").reduce((x, k) => (x == null ? undefined : x[k]), o);
+const filled = (v) => v !== undefined && v !== null && v !== "" && !(Array.isArray(v) && !v.length);
+
+/** Venture-relative files of a record type: one file, or every item of a collection. */
+export function filesOf(dir, type) {
+  const r = MODEL.records.find((x) => x.id === type);
+  const gs = (r?.paths ?? []).filter((p) => p.startsWith("instance/**/")).map((p) => p.slice("instance/**/".length));
+  const found = [];
+  for (const g of gs) {
+    if (!g.includes("*")) { if (existsSync(join(dir, g))) found.push(g); continue; }
+    const star = g.indexOf("*");
+    const folder = g.slice(0, star), rest = g.slice(star + 1);
+    if (rest.includes("*")) continue;
+    const d = join(dir, folder);
+    if (existsSync(d)) for (const f of readdirSync(d)) if (f.endsWith(rest)) found.push(folder + f);
+  }
+  if (found.length) return found;
+  const drafted = gs.filter((g) => !g.includes("*") && existsSync(join(dir, `_drafts/${g.replace(/\//g, "__")}.draft`)));
+  return drafted.length ? drafted : gs.slice(0, 1);
+}
+
+/** Whether a person confirmed one statement in a file: their write or accept of the file, or a
+ *  confirm of that statement, after the last write by anyone else. */
+export function confirmedIn(dir, file, id, seen = new Set()) {
+  if (seen.has(file)) return false;
+  seen.add(file);
+  const log = join(dir, "provenance.jsonl");
+  if (!existsSync(log)) return false;
+  const draft = `_drafts/${file.replace(/\//g, "__")}.draft`;
+  const es = readFileSync(log, "utf8").split("\n").filter(Boolean).map((l) => JSON.parse(l)).filter((e) => e.entity === file || e.entity === draft);
+  const lastAgentWrite = es.findLastIndex((e) => e.entity === file && e.activity !== "confirm" && e.activity !== "move" && e.activity !== "release" && e.agent?.kind !== "person" && e.activity !== "accept");
+  const direct = es.some((e, i) => i > lastAgentWrite && e.entity === file && (e.activity === "accept" || (e.agent?.kind === "person" && e.activity !== "confirm" && e.activity !== "move") || (e.activity === "confirm" && e.statement === id)));
+  if (direct) return true;
+  return es.filter((e) => e.activity === "move" && e.entity === file).flatMap((e) => e.derived_from ?? []).some((p) => confirmedIn(dir, p, id, seen));
+}
+
+/** Each foundation statement of a venture, with its status and value. */
+export function foundation(dir) {
+  const report = FRAME.questions.map((q) => ({ question: q.id, ask: q.ask, statements: q.statements.map((s) => {
+    if (s.derived_from) return s;
+    if (!s.record) return { id: s.id, status: "planned", note: s.note ?? null };
+    const files = filesOf(dir, s.record);
+    // A retired product no longer answers for the venture.
+    const values = files.filter((f) => existsSync(join(dir, f)) && load(join(dir, f)).status !== "retired").map((f) => ({ f, v: get(load(join(dir, f)), s.attribute) })).filter((x) => filled(x.v));
+    const drafts = files.filter((f) => existsSync(join(dir, `_drafts/${f.replace(/\//g, "__")}.draft`)));
+    if (!values.length) return { id: s.id, record: s.record, attribute: s.attribute, status: drafts.length ? "draft" : "missing" };
+    // A record with no log entry existed before the log; a person's baseline or write confirms it.
+    const confirmed = values.every(({ f }) => confirmedIn(dir, f, s.id));
+    return { id: s.id, record: s.record, attribute: s.attribute, status: drafts.length ? "draft" : confirmed ? "confirmed" : "agent",
+      value: values.length === 1 && !files[0].includes("products/") ? values[0].v : Object.fromEntries(values.map(({ f, v }) => [f, v])) };
+  }) }));
+  // A derived statement takes its source's status and shows the primary ICP profile's short form.
+  const all = report.flatMap((q) => q.statements);
+  for (const q of report) q.statements = q.statements.map((s) => {
+    if (!s.derived_from) return s;
+    const src = all.find((x) => x.id === s.derived_from) ?? { status: "missing" };
+    const out = { id: s.id, record: s.record, attribute: s.attribute, derived_from: s.derived_from, status: src.status };
+    const primary = Array.isArray(src.value) ? (src.value.find((p) => p.primary) ?? src.value[0]) : null;
+    if (primary) out.value = primary.short ?? primary.who;
+    return out;
+  });
+  return report;
+}
+
+export function problems(dir) {
+  const out = FRAME.questions.flatMap((q) => q.statements).filter((s) => s.record && !MODEL.records.some((r) => r.id === s.record)).map((s) => `frame: ${s.id} names record type ${s.record}, which the data model lacks`);
+  const there = (...fs) => fs.map((f) => join(dir, f)).find((p) => existsSync(p));
+  const icp = there("foundation/icp.json", "purpose/icp.json"), prob = there("foundation/problem.json", "purpose/validation/problem.json");
+  if (icp) {
+    const forms = new Set(existsSync(prob) ? (load(prob).forms ?? []).map((f) => f.id) : []);
+    for (const p of load(icp).profiles) for (const f of p.problem_forms ?? []) if (!forms.has(f)) out.push(`icp ${p.id}: problem form ${f} is not in the problem record`);
+    const primaries = load(icp).profiles.filter((p) => p.primary).length;
+    if (load(icp).profiles.length > 1 && primaries !== 1) out.push(`icp: ${primaries} primary profiles; exactly one is primary`);
+    // promised-to is derived from the ICP; a hand-written one that differs has drifted.
+    const p = load(icp).profiles.find((x) => x.primary) ?? load(icp).profiles[0];
+    const said = existsSync(join(dir, "venture.json")) ? load(join(dir, "venture.json")).core?.promised_to : undefined;
+    if (p && filled(said) && said !== (p.short ?? p.who)) out.push(`venture core.promised_to differs from the ICP's short form ("${p.short ?? p.who}"); it is derived from the ICP`);
+  }
+  return out;
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const arg = process.argv[2];
+  if (!arg) { console.error("usage: node schema/foundation.mjs <venture or workspace dir> [--json]"); process.exit(2); }
+  const walk = (d) => existsSync(join(d, "venture.json")) ? [d] : readdirSync(d, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith(".") && !e.name.startsWith("_")).flatMap((e) => walk(join(d, e.name)));
+  const dirs = walk(arg);
+  const errs = dirs.flatMap((d) => problems(d).map((p) => `${d}: ${p}`));
+  if (process.argv.includes("--json")) console.log(JSON.stringify(dirs.length === 1 ? foundation(dirs[0]) : Object.fromEntries(dirs.map((d) => [d, foundation(d)])), null, 2));
+  else for (const d of dirs) {
+    if (dirs.length > 1) console.log(`\n${d}`);
+    for (const q of foundation(d)) console.log(`${q.question.padEnd(8)} ${q.ask}\n${q.statements.map((s) => `         ${s.id.padEnd(16)} ${s.status}${s.value !== undefined ? `: ${JSON.stringify(s.value).slice(0, 90)}` : ""}`).join("\n")}`);
+  }
+  for (const e of errs) console.error(`FAIL  ${e}`);
+  process.exit(errs.length ? 1 : 0);
+}

package/schema/founder-agreement.schema.json

@@ -0,0 +1,83 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "founder-agreement.schema.json",
+  "title": "Founder agreement",
+  "description": "The summary of what founders agreed with each other, at <venture>/governance/founder-agreement.json (EE-022), with the full text (or the signed document's location) in founder-agreement.md beside it. Equity and vesting live in ownership.json and are not repeated here. Required once two or more founders share ownership.",
+  "type": "object",
+  "required": [
+    "founders",
+    "signed",
+    "document"
+  ],
+  "additionalProperties": false,
+  "properties": {
+    "signed": {
+      "type": [
+        "string",
+        "null"
+      ],
+      "format": "date",
+      "description": "null until every founder has signed"
+    },
+    "document": {
+      "type": "string",
+      "description": "Path to the prose agreement or the signed document"
+    },
+    "founders": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "required": [
+          "holder",
+          "role",
+          "commitment",
+          "ip_assigned"
+        ],
+        "additionalProperties": false,
+        "properties": {
+          "holder": {
+            "type": "string",
+            "description": "Holder id in ownership.json"
+          },
+          "role": {
+            "type": "string"
+          },
+          "commitment": {
+            "enum": [
+              "full-time",
+              "part-time"
+            ]
+          },
+          "ip_assigned": {
+            "type": "boolean",
+            "description": "Has assigned to the venture the work and ideas they brought or make"
+          }
+        }
+      }
+    },
+    "departure": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "good_leaver": {
+          "type": "string"
+        },
+        "bad_leaver": {
+          "type": "string"
+        },
+        "buyback": {
+          "enum": [
+            "unvested-only",
+            "unvested-at-cost",
+            "none"
+          ]
+        }
+      }
+    },
+    "deadlock": {
+      "type": "string",
+      "description": "How founders break a tie"
+    }
+  }
+}

package/schema/gate.mjs

@@ -0,0 +1,39 @@
+// The gate (EE-073): checks that run before a write. One per venture. Static rules live in
+// naive.config.json. Per-package rules are the gates on each package definition. The gate
+// matches the router's path patterns and never calls a model. Confidence routing reads a
+// score that was already computed.
+
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+
+const repo = new URL("..", import.meta.url).pathname;
+
+/** Package gates, imported from packages/<name>/package.json. No model, no network. */
+export function packageGates() {
+  const dir = join(repo, "packages");
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir).flatMap((name) => {
+    const p = join(dir, name, "package.json");
+    if (!existsSync(p)) return [];
+    const pkg = JSON.parse(readFileSync(p, "utf8"));
+    return (pkg.gates ?? []).map((rule) => ({ package: pkg.name, rule }));
+  });
+}
+
+/**
+ * Whether an agent write is held as a draft. fail_closed names path prefixes
+ * (foundation, or foundation/problem). A person is not held.
+ */
+export function hold(config, route, actor) {
+  if (actor === "person") return null;
+  const closed = config?.fail_closed ?? [];
+  const hit = closed.find((g) => route === g || route.startsWith(`${g}/`));
+  return hit ? { hold: "draft", rule: hit } : null;
+}
+
+/** The venture's naive.config.json, or an empty config. */
+export function configOf(dir) {
+  const f = dir && join(dir, "naive.config.json");
+  if (!f || !existsSync(f)) return { fail_closed: [] };
+  return JSON.parse(readFileSync(f, "utf8")).gate ?? { fail_closed: [] };
+}