naive-framework 0.0.0-stage → 0.2.0

package/schema/setup.mjs

@@ -0,0 +1,164 @@
+// Setup (EE-083): the questions that establish a venture's structure, in order: its people and their
+// hats, where each function keeps its truth, the strategic foundation and the first decisions (the decision
+// docket), and a goal for the discovery phase. It holds no view. The naive-setup skill
+// (interface/skills/naive-setup) renders it in the model's harness, as a Claude artifact where there is one;
+// interface/dev/setup.mjs serves the same state to a browser.
+//
+//   node schema/setup.mjs <venture dir> state                     the state, as JSON
+//   node schema/setup.mjs <venture dir> artifact                  the state rendered into the skill's artifact template
+//   node schema/setup.mjs <venture dir> answer <decision id> <the founder's words> [--via mcp]
+//   node schema/setup.mjs <venture dir> point <function> <system> [address] [--via mcp]
+//   node schema/setup.mjs <venture dir> confirm [--yes]          confirm the answers the model relayed, as the founder
+
+import { spawnSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+
+const repo = new URL("..", import.meta.url).pathname;
+const load = (p) => JSON.parse(readFileSync(p, "utf8"));
+export const TEMPLATE = "interface/skills/naive-setup/artifact.html";
+
+const GOAL = "discovery-goal";
+
+export async function state(dir) {
+  const { decisions } = await import("./decisions.mjs");
+  const v = load(join(dir, "venture.json"));
+  const people = existsSync(join(dir, "people/people.json")) ? load(join(dir, "people/people.json")) : null;
+  const sources = existsSync(join(dir, "knowledge/sources.json")) ? load(join(dir, "knowledge/sources.json")) : { sources: [], records: {} };
+  const catalog = load(join(repo, "schema/systems-catalog.json"));
+  const types = load(join(repo, "schema/venture-types.json")).types;
+  const all = decisions(dir).decisions;
+  // The roots (venture, foundation) structure the docket; they are not questions to answer here.
+  const docket = all.filter((d) => d.id !== GOAL && d.status !== "deferred" && !["venture", "foundation"].includes(d.id));
+  const now = docket.filter((d) => d.render === "now" || d.status === "decided");
+  const goal = all.find((d) => d.id === GOAL) ?? null;
+  const settled = now.filter((d) => d.status === "decided").length;
+  const pointed = Object.values(sources.functions ?? {}).filter((f) => f.systems.length).length;
+  const steps = { venture: true, people: !!people, truth: pointed > 0, docket: now.length > 0 && settled === now.length, goal: goal?.status === "decided" };
+  return {
+    venture: { id: v.id, name: v.name, phase: v.phase, type: types.find((t) => t.id === v.type) ?? null },
+    people, functions: sources.functions ?? {}, truth: sources.truth ?? "local",
+    catalog, docket: now.map((d) => ({ id: d.id, question: d.question, source: d.source, status: d.status, options: d.options ?? [], answer: d.answer ?? null, why: d.why ?? [], statement: d.statement ?? null, relayed: relayed(d) })),
+    // Answers the model wrote down from the founder's words; they wait for the founder to confirm them.
+    waiting: [...now, ...(goal ? [goal] : [])].filter(relayed).map((d) => ({ id: d.id, question: d.question, answer: d.answer })),
+    later: docket.filter((d) => d.render !== "now" && d.status !== "decided").length,
+    goal: goal ? { status: goal.status, answer: goal.answer ?? null, relayed: relayed(goal) } : null,
+    steps, done: Object.values(steps).every(Boolean), counts: { settled, of: now.length },
+    rho: existsSync(join(repo, "platform/integrations/rho.mjs")),
+  };
+}
+
+// An open decision whose wording an agent wrote: in setup, the founder's words the model relayed.
+const relayed = (d) => d.status !== "decided" && !!d.answer && d.provenance?.drafted_by?.kind === "agent";
+
+const founderName = (dir) => existsSync(join(dir, "people/people.json")) ? load(join(dir, "people/people.json")).people[0]?.name ?? "Founder" : "Founder";
+
+// One answer: a decision on file is approved; a foundation statement (or the goal) becomes a decision a person approves.
+export async function decide(dir, { id, answer, via = "api", where = "/setup" }) {
+  const { approve, decisions, propose } = await import("./decisions.mjs");
+  if (!answer || !String(answer).trim()) return { ok: false, error: "write an answer first" };
+  const by = founderName(dir);
+  const d = decisions(dir).decisions.find((x) => x.id === id);
+  if (id === GOAL && !d) {
+    const p = propose(dir, { id: GOAL, question: "What must be true for the venture to leave discovery? Name the goal this phase works toward.", decides: { record: "telos", path: "foundation/telos.json" }, layer: "purpose", needed_in: "discovery", boundary: "fail-open" }, { via });
+    if (!p.ok) return p;
+    return approve(dir, GOAL, { by, answer: String(answer).trim(), via, note: `set at ${where}` });
+  }
+  if (!d) return { ok: false, error: `no decision ${id}` };
+  if (d.source === "foundation") {
+    const sid = id.replace(/^foundation-/, "");
+    const did = `statement-${sid}`;
+    const p = propose(dir, { id: did, question: d.question, statement: sid, decides: d.decides, layer: d.layer === "system" ? "purpose" : d.layer, needed_in: d.needed_in }, { via });
+    if (!p.ok) return p;
+    return approve(dir, did, { by, answer: String(answer).trim(), via, note: `the founder's words at ${where}` });
+  }
+  return approve(dir, id, { by, answer: String(answer).trim(), via, note: `decided at ${where}` });
+}
+
+// One pointer: where a function keeps its truth, merged into knowledge/sources.json through the router.
+export async function point(dir, { fn, system, address, via = "api", actor = "person", agentId }) {
+  const catalog = load(join(repo, "schema/systems-catalog.json"));
+  if (!catalog.functions[fn]?.includes(system)) return { ok: false, error: `${system} is not offered for ${fn}` };
+  const file = join(dir, "knowledge/sources.json");
+  const map = existsSync(file) ? load(file) : { sources: [], records: {}, truth: "local" };
+  const f = (map.functions ??= {})[fn] ??= { systems: [] };
+  const entry = { system, ...(address ? { address } : {}), status: "pointed" };
+  if (system === "rho" && existsSync(join(repo, "platform/integrations/rho.mjs"))) {
+    const live = Boolean(process.env.RHO_API_TOKEN);
+    const r = spawnSync("node", [join(repo, "platform/integrations/rho.mjs"), "sync", "--venture", dir, ...(live ? ["--live"] : [])], { encoding: "utf8", env: process.env });
+    if (r.status === 0) Object.assign(entry, { status: "connected", synced: new Date().toISOString().replace(/\.\d+Z$/, "Z"), address: address || (live ? "live" : "sandbox") });
+  }
+  f.systems = [...f.systems.filter((s) => s.system !== system), entry];
+  const { call } = await import("../interface/router.mjs");
+  const r = await call({ workspace: dirname(dir), venture: basename(dir), route: "knowledge/knowledge-sources", action: "write", input: map, actor, ...(agentId ? { actor_id: agentId } : {}), via, provenance: { note: `${fn}: ${system}${address ? ` at ${address}` : ""} (${entry.status})` } });
+  return r.ok ? { ok: true, result: entry } : r;
+}
+
+/** The model relays the founder's answer: proposed with the founder's words as its wording, by an agent,
+ *  so it stays open until the founder confirms it (an agent never decides, EE-058). */
+export async function relay(dir, { id, answer, agentId, harness, model }) {
+  const { decisions, propose } = await import("./decisions.mjs");
+  if (!answer || !String(answer).trim()) return { ok: false, error: "pass the founder's answer, in their words" };
+  const words = String(answer).trim();
+  const note = `the founder's words, relayed from ${harness ?? "the model's harness"} during setup`;
+  const opts = { agentId, via: "mcp", harness, model };
+  const d = decisions(dir).decisions.find((x) => x.id === id);
+  if (id === GOAL) return propose(dir, { ...(d ? {} : { decides: { record: "telos", path: "foundation/telos.json" }, layer: "purpose", needed_in: "discovery", boundary: "fail-open" }), id: GOAL, question: d?.question ?? "What must be true for the venture to leave discovery? Name the goal this phase works toward.", answer: words, note }, opts);
+  if (!d) return { ok: false, error: `no decision ${id}` };
+  if (d.status === "decided") return { ok: false, error: `${id} is decided; only the founder can change it` };
+  if (d.source === "foundation") {
+    const sid = id.replace(/^foundation-/, "");
+    return propose(dir, { id: `statement-${sid}`, question: d.question, statement: sid, decides: d.decides, layer: d.layer === "system" ? "purpose" : d.layer, needed_in: d.needed_in, answer: words, note }, opts);
+  }
+  return propose(dir, { id, question: d.question, answer: words, note }, opts);
+}
+
+/** The founder confirms the answers the model relayed, at the keyboard: each becomes a decision they made. */
+export async function confirm(dir, { by = founderName(dir) } = {}) {
+  const { approve } = await import("./decisions.mjs");
+  const out = [];
+  for (const w of (await state(dir)).waiting) {
+    const r = approve(dir, w.id, { by, via: "cli", note: `confirmed at setup: ${by}'s words, relayed by the model` });
+    if (!r.ok) return { ...r, confirmed: out };
+    out.push(w.id);
+  }
+  return { ok: true, result: { confirmed: out, by } };
+}
+
+/** The state rendered into the skill's artifact template: one self-contained page, no network. */
+export async function artifact(dir) {
+  const s = await state(dir);
+  const data = JSON.stringify(s).replace(/</g, "\\u003c");
+  return readFileSync(join(repo, TEMPLATE), "utf8").replace("__NAIVE_SETUP_STATE__", () => data);
+}
+
+if (process.argv[1] && resolve(process.argv[1]) === new URL(import.meta.url).pathname) {
+  const [dirArg, cmd, ...rest] = process.argv.slice(2);
+  const flag = (n) => { const i = rest.indexOf(`--${n}`); if (i < 0) return undefined; const v = rest[i + 1]; rest.splice(i, 2); return v; };
+  const via = flag("via") ?? "cli";
+  if (!["cli", "mcp", "api"].includes(via)) { console.error(`--via is cli, mcp or api, not ${via}`); process.exit(2); }
+  if (!dirArg || !existsSync(join(dirArg, "venture.json"))) { console.error("usage: node schema/setup.mjs <venture dir> state|artifact|answer|point|confirm ..."); process.exit(2); }
+  const dir = resolve(dirArg);
+  let r;
+  if (cmd === "state") r = { ok: true, result: await state(dir) };
+  else if (cmd === "artifact") { process.stdout.write(await artifact(dir)); process.exit(0); }
+  else if (cmd === "answer") r = await decide(dir, { id: rest[0], answer: rest.slice(1).join(" "), via, where: via === "mcp" ? "setup in the model's harness" : "setup" });
+  else if (cmd === "confirm") {
+    const waiting = (await state(dir)).waiting;
+    if (!waiting.length) { console.log("Nothing waits for you to confirm."); process.exit(0); }
+    for (const w of waiting) console.log(`\n  ${w.question}\n  > ${w.answer}`);
+    let yes = rest.includes("--yes");
+    if (!yes) {
+      const { createInterface } = await import("node:readline/promises");
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      yes = (await rl.question(`\nAre these ${waiting.length} answers yours, as written? Type yes to confirm them: `)).trim().toLowerCase() === "yes";
+      rl.close();
+    }
+    if (!yes) { console.log("Nothing confirmed. Change an answer in the chat, or run this again."); process.exit(1); }
+    r = await confirm(dir);
+  }
+  else if (cmd === "point") r = await point(dir, { fn: rest[0], system: rest[1], address: rest[2], via });
+  else { console.error(`unknown command ${cmd}: state, artifact, answer, point or confirm`); process.exit(2); }
+  console.log(JSON.stringify(r.ok && cmd === "state" ? r.result : r, null, 2));
+  process.exit(r.ok ? 0 : 1);
+}

package/schema/site-presence.schema.json

@@ -0,0 +1,337 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "site-presence.schema.json",
+  "title": "Site presence",
+  "description": "How present a venture's public records are on its marketing site, weighed by who the site must speak to now (EE-062, EE-063). Written by operations/marketing/site/presence.mjs from a read of the site; version 0.x, ours and unevaluated.",
+  "type": "object",
+  "required": [
+    "version",
+    "site",
+    "judged_by",
+    "facts",
+    "score",
+    "audiences",
+    "pages",
+    "items",
+    "fix_first",
+    "icp",
+    "sitemap"
+  ],
+  "properties": {
+    "version": {
+      "type": "string"
+    },
+    "site": {
+      "type": "string"
+    },
+    "venture": {
+      "type": [
+        "string",
+        "null"
+      ]
+    },
+    "read_via": {
+      "enum": [
+        "firecrawl",
+        "fetch"
+      ]
+    },
+    "read_at": {
+      "type": "string"
+    },
+    "judged_by": {
+      "enum": [
+        "jev",
+        "keywords"
+      ]
+    },
+    "facts": {
+      "type": "object"
+    },
+    "score": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 100
+    },
+    "audiences": {
+      "type": "object",
+      "additionalProperties": {
+        "type": "object",
+        "required": [
+          "weight"
+        ],
+        "properties": {
+          "weight": {
+            "type": "number"
+          },
+          "score": {
+            "type": [
+              "integer",
+              "null"
+            ]
+          }
+        }
+      }
+    },
+    "pages": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": [
+          "path",
+          "type",
+          "level"
+        ],
+        "properties": {
+          "path": {
+            "type": "string"
+          },
+          "title": {
+            "type": "string"
+          },
+          "type": {
+            "type": "string"
+          },
+          "level": {
+            "enum": [
+              "home",
+              "nav",
+              "linked",
+              "anywhere"
+            ]
+          }
+        }
+      }
+    },
+    "items": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": [
+          "id",
+          "label",
+          "record",
+          "need",
+          "required",
+          "score",
+          "note"
+        ],
+        "properties": {
+          "id": {
+            "type": "string"
+          },
+          "label": {
+            "type": "string"
+          },
+          "record": {
+            "type": "string"
+          },
+          "need": {
+            "type": "number"
+          },
+          "required": {
+            "enum": [
+              "home",
+              "nav",
+              "linked",
+              "anywhere"
+            ]
+          },
+          "for": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          },
+          "at": {
+            "enum": [
+              "home",
+              "nav",
+              "linked",
+              "anywhere",
+              null
+            ]
+          },
+          "score": {
+            "enum": [
+              0,
+              0.5,
+              1
+            ]
+          },
+          "found": {
+            "type": "array"
+          },
+          "note": {
+            "type": "string"
+          },
+          "evidence": {
+            "type": "array",
+            "description": "Who needs the item and why: each audience's weight, the item's importance to it, and the reason (for customers, from the customer types)",
+            "items": {
+              "type": "object",
+              "required": [
+                "audience",
+                "need",
+                "why",
+                "source"
+              ],
+              "properties": {
+                "audience": {
+                  "type": "string"
+                },
+                "weight": {
+                  "type": "number"
+                },
+                "importance": {
+                  "type": "number"
+                },
+                "need": {
+                  "type": "number"
+                },
+                "why": {
+                  "type": "string"
+                },
+                "source": {
+                  "enum": [
+                    "customer types",
+                    "matrix"
+                  ]
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "fix_first": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "icp": {
+      "type": "object",
+      "required": [
+        "text",
+        "source",
+        "cite",
+        "types"
+      ],
+      "description": "Who the site is for and where that comes from: the founder's words, the venture's ICP record, or inferred from the home page; and the customer types Jev placed it in",
+      "properties": {
+        "text": {
+          "type": "string"
+        },
+        "source": {
+          "enum": [
+            "founder",
+            "record",
+            "inferred"
+          ]
+        },
+        "cite": {
+          "type": "string"
+        },
+        "types": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "required": [
+              "id",
+              "label"
+            ],
+            "properties": {
+              "id": {
+                "type": "string"
+              },
+              "label": {
+                "type": "string"
+              },
+              "p": {
+                "type": [
+                  "number",
+                  "null"
+                ]
+              }
+            }
+          }
+        }
+      }
+    },
+    "sitemap": {
+      "type": "array",
+      "description": "The site's routes as a tree from the home page, each rated on the items that belong there; ghost routes are pages the venture's priorities call for that the site lacks",
+      "items": {
+        "type": "object",
+        "required": [
+          "path",
+          "parent",
+          "label",
+          "type",
+          "level",
+          "read",
+          "rating",
+          "expected",
+          "found",
+          "missing"
+        ],
+        "properties": {
+          "path": {
+            "type": "string"
+          },
+          "parent": {
+            "type": [
+              "string",
+              "null"
+            ]
+          },
+          "label": {
+            "type": "string"
+          },
+          "type": {
+            "type": "string"
+          },
+          "level": {
+            "enum": [
+              "home",
+              "nav",
+              "linked",
+              "anywhere"
+            ]
+          },
+          "read": {
+            "type": "boolean"
+          },
+          "rating": {
+            "type": [
+              "integer",
+              "null"
+            ]
+          },
+          "expected": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          },
+          "found": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          },
+          "missing": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          },
+          "ghost": {
+            "type": "boolean"
+          }
+        }
+      }
+    }
+  }
+}

package/schema/stale.mjs

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+// Stale summaries (V-9). In Next.js, content from a CMS is cached for a long time, and the CMS calls a
+// webhook that revalidates its tag when the content changes. In Naive a system of record (a CRM, a bank
+// such as Rho) notifies the venture that something it holds changed, and every summary that reads it is
+// marked stale until it is written again. What reads what is already recorded:
+//
+//   - provenance: a record whose latest write was derived from the changed item (derived_from names its
+//     path or its <source>://<path> address, or a folder that holds it) reads it;
+//   - the where-used list (knowledge/where-used.json, V-4): every child of a fact whose parent route is
+//     the changed record repeats it.
+//
+// Receiving the notification over the network is the platform's (platform/webhooks/server.mjs); this is
+// the framework part, offline: notify() marks, staleOf() answers for one file (the router adds it to a
+// read), and a summary is fresh again once it is written after the mark. Marks live in
+// <venture>/.naive/stale.json, never in the records.
+//
+//   node schema/stale.mjs <venture dir> [--json]                                   what is stale now
+//   node schema/stale.mjs <venture dir> --notify --source <id> --path <p> [--path <q>] [--version <v>]
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { entries } from "../interface/provenance.mjs";
+import { resolve as resolveRoute } from "../interface/router.mjs";
+import { address } from "../knowledge/connectors/contract.mjs";
+import { LOCAL, sourcesOf } from "../knowledge/connectors/index.mjs";
+
+export const MARKS = ".naive/stale.json";
+const load = (p) => JSON.parse(readFileSync(p, "utf8"));
+const now = () => new Date().toISOString();
+const WRITES = new Set(["write", "accept", "baseline"]);
+
+const readMarks = (dir) => (existsSync(join(dir, MARKS)) ? load(join(dir, MARKS)) : { marks: [] });
+
+// The latest write of each file in the log.
+function lastWrites(dir) {
+  const last = new Map();
+  for (const e of entries(dir)) if (WRITES.has(e.activity) && !e.source) last.set(e.entity, e);
+  return last;
+}
+
+const covers = (d, item) => d === item || (d.endsWith("/") ? item.startsWith(d) : item.startsWith(`${d}/`));
+
+/**
+ * A system of record says items changed. Marks every summary that reads them stale and returns what it
+ * marked. source: a source id from knowledge/sources.json (venture for the venture's own folder);
+ * paths: the changed items, as paths inside that source.
+ */
+export function notify(dir, { source, paths, version, at = now(), via = "framework" }) {
+  const map = sourcesOf(dir);
+  if (!source || !map.sources.some((s) => s.id === source)) throw new Error(`no source ${source} in ${dir}'s knowledge/sources.json: one of ${map.sources.map((s) => s.id).join(", ")}`);
+  paths = [paths].flat().filter(Boolean);
+  if (!paths.length) throw new Error("a notification names at least one changed path");
+  // The changed items as the venture refers to them: the address always, and the bare path for its own folder
+  // or for a source whose records the venture keeps a local copy of at the same path.
+  const items = paths.flatMap((p) => [address(source, p), ...(source === LOCAL || existsSync(join(dir, p)) ? [p] : [])]);
+  const readers = new Map();
+  for (const [file, e] of lastWrites(dir)) {
+    if (items.includes(file)) continue;
+    const hit = (e.derived_from ?? []).find((d) => items.some((i) => covers(d, i)));
+    if (hit) readers.set(file, { via: "provenance", reads: hit });
+  }
+  const wu = join(dir, "knowledge/where-used.json");
+  if (existsSync(wu)) {
+    for (const fact of load(wu).facts ?? []) {
+      const { r, params } = resolveRoute(fact.parent.route);
+      if (!r || r.kind !== "record") continue;
+      const files = (r.collection === "item" ? r.files.map((f) => f.replace("*", params.id)) : r.files).filter((f) => !f.includes("*"));
+      if (!files.some((f) => items.includes(f) || items.includes(address(source, f)))) continue;
+      for (const c of fact.children) readers.set(c.source === LOCAL ? c.path : address(c.source, c.path), { via: "where-used", reads: fact.parent.route, fact: fact.id });
+    }
+  }
+  const state = readMarks(dir);
+  const because = { source, paths, ...(version ? { version } : {}), at, via };
+  for (const [file, how] of readers) state.marks.push({ file, ...how, because, marked_at: now() });
+  state.notifications = [...(state.notifications ?? []), { ...because, marked: readers.size, received_at: now() }].slice(-100);
+  mkdirSync(join(dir, ".naive"), { recursive: true });
+  writeFileSync(join(dir, MARKS), JSON.stringify(state, null, 2) + "\n");
+  return { source, paths, stale: [...readers.keys()].sort() };
+}
+
+/** Whether one file is stale: the marks made after its latest write, or null when it is fresh. */
+export function staleOf(dir, file) {
+  if (!existsSync(join(dir, MARKS))) return null;
+  const written = lastWrites(dir).get(file)?.at ?? "";
+  const live = readMarks(dir).marks.filter((m) => m.file === file && m.marked_at > written);
+  return live.length ? { since: live[0].marked_at, because: live.map((m) => ({ ...m.because, reads: m.reads, via: m.via })), fix: `write ${file} again from the changed source; it is fresh once written` } : null;
+}
+
+/** Every stale file in the venture now. */
+export function stale(dir) {
+  const files = [...new Set(readMarks(dir).marks.map((m) => m.file))];
+  return files.map((f) => ({ file: f, ...staleOf(dir, f) })).filter((x) => x.since).sort((a, b) => a.file.localeCompare(b.file));
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const a = process.argv.slice(2);
+  const dir = a[0];
+  const all = (n) => a.flatMap((x, i) => (x === `--${n}` ? [a[i + 1]] : []));
+  if (!dir || !existsSync(join(dir, "venture.json"))) { console.error("usage: node schema/stale.mjs <venture dir> [--json] | --notify --source <id> --path <p> [--version <v>]"); process.exit(2); }
+  try {
+    if (a.includes("--notify")) {
+      const r = notify(dir, { source: all("source")[0], paths: all("path"), version: all("version")[0], via: "cli" });
+      if (a.includes("--json")) console.log(JSON.stringify(r, null, 2));
+      else console.log(r.stale.length ? `${r.stale.length} stale: ${r.stale.join(", ")}` : "nothing reads what changed, so nothing is stale");
+    } else {
+      const s = stale(dir);
+      if (a.includes("--json")) console.log(JSON.stringify(s, null, 2));
+      else console.log(s.length ? s.map((x) => `stale  ${x.file}  since ${x.since}: ${x.because.map((b) => `${b.source} changed ${b.paths.join(", ")}`).join("; ")}`).join("\n") : "nothing is stale");
+    }
+  } catch (e) { console.error(e.message); process.exit(1); }
+}

package/schema/start-release.mjs

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+// naive start (I-17, C-12): serves a venture's release read-only over local HTTP. No router: it reads
+// <venture>/.release/ and nothing else (schema/release-read.mjs), as a CDN serves a static shell. It
+// reads the manifest on each request, so an item added with build-release --add shows at once (C-18).
+// It listens on 127.0.0.1 only. The paths are listed in schema/release-read.mjs; /card.svg is the
+// release card drawn by the interface (interface/release-card.mjs).
+//
+//   node schema/start-release.mjs <venture dir> [--port n]     serve; --port 0 picks a free port (default 4330)
+//   node schema/start-release.mjs <venture dir> --get <path>   answer one path and exit, without a server
+
+import { existsSync } from "node:fs";
+import { createServer } from "node:http";
+import { join } from "node:path";
+import { svg } from "../interface/release-card.mjs";
+import { answer, readRelease } from "./release-read.mjs";
+
+const args = process.argv.slice(2);
+const opt = (n) => { const i = args.indexOf(`--${n}`); return i >= 0 ? args[i + 1] : undefined; };
+const values = new Set(["port", "get", "now"].flatMap((n) => (opt(n) !== undefined ? [opt(n)] : [])));
+const dir = args.find((a) => !a.startsWith("--") && !values.has(a));
+if (!dir || !existsSync(join(dir, "venture.json"))) { console.error("usage: node schema/start-release.mjs <venture dir> [--port n] | --get <path>"); process.exit(2); }
+if (!readRelease(dir)) { console.error(`no release in ${dir}: run node schema/build-release.mjs ${dir} first`); process.exit(1); }
+
+if (opt("get") !== undefined) {
+  const a = answer(dir, "GET", opt("get"), { draw: svg });
+  process.stdout.write(a.body);
+  process.exit(a.status < 400 ? 0 : 1);
+}
+
+const port = opt("port") === undefined ? 4330 : Number(opt("port"));
+if (!Number.isInteger(port) || port < 0 || port > 65535) { console.error(`--port ${opt("port")} is not a port`); process.exit(2); }
+const server = createServer((req, res) => {
+  const a = answer(dir, req.method, req.url ?? "/", { draw: svg });
+  res.writeHead(a.status, { "content-type": a.type, "cache-control": "no-cache", ...(a.allow ? { allow: a.allow } : {}) });
+  res.end(req.method === "HEAD" ? undefined : a.body);
+});
+server.listen(port, "127.0.0.1", () => {
+  const m = readRelease(dir);
+  console.log(`serving release ${m.release} of ${m.venture} read-only at http://127.0.0.1:${server.address().port}/`);
+});
+for (const s of ["SIGINT", "SIGTERM"]) process.on(s, () => server.close(() => process.exit(0)));