naive-framework 0.0.0-stage → 0.2.0

package/schema/fund-thesis.schema.json

@@ -0,0 +1,87 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "fund-thesis.schema.json",
+  "title": "Fund thesis",
+  "description": "What a fund invests in and why it wins (fund/thesis.json): rounds, sectors, geographies, check size, and the edge. The fund's strategic foundation, as the problem record is a startup's.",
+  "type": "object",
+  "required": [
+    "venture",
+    "statement",
+    "rounds",
+    "sectors",
+    "check_size"
+  ],
+  "additionalProperties": false,
+  "properties": {
+    "venture": {
+      "type": "string"
+    },
+    "statement": {
+      "type": "string",
+      "description": "The thesis in one or two sentences"
+    },
+    "rounds": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "enum": [
+          "pre-seed",
+          "seed",
+          "series-a",
+          "series-b",
+          "growth",
+          "late"
+        ]
+      }
+    },
+    "sectors": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "string"
+      }
+    },
+    "geographies": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "check_size": {
+      "type": "object",
+      "required": [
+        "min",
+        "max",
+        "currency"
+      ],
+      "additionalProperties": false,
+      "properties": {
+        "min": {
+          "type": "number",
+          "minimum": 0
+        },
+        "max": {
+          "type": "number",
+          "minimum": 0
+        },
+        "currency": {
+          "type": "string",
+          "pattern": "^[A-Z]{3}$"
+        }
+      }
+    },
+    "ownership_target": {
+      "type": "number",
+      "minimum": 0,
+      "maximum": 1,
+      "description": "Target ownership at entry, as a fraction"
+    },
+    "edge": {
+      "type": "string",
+      "description": "Why this fund sees, wins or helps deals others do not"
+    },
+    "why_now": {
+      "type": "string"
+    }
+  }
+}

package/schema/gate-drafts.mjs

@@ -0,0 +1,130 @@
+#!/usr/bin/env node
+// Held writes (X-2): where the gate's drafts wait and for whom. The gate (schema/gate.mjs) decides;
+// this stores what it held. A held write lands in _drafts/ as before, with a sidecar
+// (<draft>.gate) saying which rule held it and the function owner it was sent to. Where a rule (or
+// gate.variants in naive.config.json) keeps variants, a second agent draft that differs from the
+// first is kept beside it instead of replacing it, like an A/B rewrite: variant a is <draft>,
+// variant b is <draft>.b, and so on. One open decision, in the decisions/ folder beside the record,
+// asks the founder which to accept. Accepting one variant (mentura accept <route> --pick b) decides
+// that decision and removes the others.
+//
+//   node schema/gate-drafts.mjs <venture dir> [--owner <role>] [--json]   the drafts waiting, by owner
+
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { approve } from "./decisions.mjs";
+
+const sha = (s) => createHash("sha256").update(s).digest("hex");
+const LETTERS = "abcdefghijklmnopqrstuvwxyz";
+export const sidecarOf = (draft) => `${draft}.gate`;
+export const variantPath = (draft, v) => (v === "a" ? draft : `${draft}.${v}`);
+
+/** The decision that holds a record's variants side by side: its id and venture-relative file. */
+export function variantsDecision(file) {
+  const stem = file.replace(/\.json$/, "");
+  const id = `variants-${stem.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "")}`;
+  const at = dirname(file) === "." ? "decisions" : `${dirname(file)}/decisions`;
+  return { id, path: `${at}/${basename(stem)}.variants.decision.json` };
+}
+
+const readJson = (f) => JSON.parse(readFileSync(f, "utf8"));
+
+/** The sidecar of a draft, or null. */
+export function sidecar(dir, draft) {
+  const f = join(dir, sidecarOf(draft));
+  return existsSync(f) ? readJson(f) : null;
+}
+
+/**
+ * Stores a held write. dir: the venture; draft: _drafts/<file>.draft; file: the record's path; text:
+ * the record; verdict: the gate's, or null when only a decision class held it; route; agent: who wrote it.
+ * Returns { written, variant, variants, decision }.
+ */
+export function writeHeld(dir, { draft, file, text, verdict, route, agent = {} }) {
+  const dest = join(dir, draft);
+  mkdirSync(dirname(dest), { recursive: true });
+  const at = new Date().toISOString();
+  const by = agent.id ?? agent.kind ?? "agent";
+  const meta = sidecar(dir, draft);
+  const keep = !!verdict?.variants && existsSync(dest);
+  if (!keep) {
+    writeFileSync(dest, text);
+    for (const v of meta?.variants ?? []) if (v.variant !== "a") rmSync(join(dir, variantPath(draft, v.variant)), { force: true });
+    if (verdict && verdict.then !== "pass") {
+      writeFileSync(join(dir, sidecarOf(draft)), JSON.stringify({ route, file, rule: verdict.rule, source: verdict.source, then: verdict.then,
+        ...(verdict.owner ? { owner: verdict.owner, function: verdict.function ?? null } : {}), variants: [{ variant: "a", file: draft, by, at, sha256: sha(text) }] }, null, 2) + "\n");
+    } else rmSync(join(dir, sidecarOf(draft)), { force: true });
+    return { written: draft, variant: "a" };
+  }
+  // Variants: the first draft stays as a; a draft equal to one already held is that variant.
+  const variants = meta?.variants?.length ? meta.variants : [{ variant: "a", file: draft, by: "agent", at, sha256: sha(readFileSync(dest)) }];
+  const same = variants.find((v) => v.sha256 === sha(text));
+  if (same) return { written: same.file, variant: same.variant, variants: variants.map((v) => v.variant), decision: meta?.decision ?? null };
+  const next = LETTERS[variants.length];
+  if (!next) throw new Error(`${route} already holds ${variants.length} drafts side by side; accept one first`);
+  const vfile = variantPath(draft, next);
+  writeFileSync(join(dir, vfile), text);
+  variants.push({ variant: next, file: vfile, by, at, sha256: sha(text) });
+  const dec = variantsDecision(file);
+  const record = {
+    id: dec.id,
+    question: `Which draft of ${route} do you accept?`,
+    decides: { path: file },
+    parent: "venture",
+    boundary: "fail-open",
+    status: "open",
+    options: variants.map((v) => `${v.variant}: drafted by ${v.by} at ${v.at}`),
+    answer: null,
+    note: `The gate kept ${variants.length} differing drafts side by side (rule ${verdict.rule}). Accept one: mentura accept ${route} --pick <letter>`,
+    provenance: { drafted_by: { kind: "framework" } },
+  };
+  mkdirSync(dirname(join(dir, dec.path)), { recursive: true });
+  writeFileSync(join(dir, dec.path), JSON.stringify(record, null, 2) + "\n");
+  writeFileSync(join(dir, sidecarOf(draft)), JSON.stringify({ ...(meta ?? { route, file, rule: verdict.rule, source: verdict.source, then: verdict.then, ...(verdict.owner ? { owner: verdict.owner, function: verdict.function ?? null } : {}) }), variants, decision: dec.id }, null, 2) + "\n");
+  return { written: vfile, variant: next, variants: variants.map((v) => v.variant), decision: dec.id };
+}
+
+/** The file of one variant of a draft, to accept. Throws when a draft holds variants and none, or an unknown one, is picked. */
+export function pick(dir, draft, letter) {
+  const meta = sidecar(dir, draft);
+  const vs = meta?.variants ?? [];
+  if (vs.length > 1 && !letter) throw new Error(`${meta.route} holds ${vs.length} drafts side by side (${vs.map((v) => v.variant).join(", ")}): pick one with --pick <letter>`);
+  if (!letter || letter === "a") return draft;
+  const v = vs.find((x) => x.variant === letter);
+  if (!v) throw new Error(`no draft ${letter} of ${meta?.route ?? draft}${vs.length ? ` (there are ${vs.map((x) => x.variant).join(", ")})` : ""}`);
+  return v.file;
+}
+
+/** After a person accepts a draft: removes every variant and the sidecar, and decides the variants decision. */
+export function settle(dir, draft, { picked = "a", by } = {}) {
+  const meta = sidecar(dir, draft);
+  for (const v of meta?.variants ?? []) rmSync(join(dir, v.file), { force: true });
+  rmSync(join(dir, draft), { force: true });
+  rmSync(join(dir, sidecarOf(draft)), { force: true });
+  if (!meta?.decision) return { picked };
+  const d = approve(dir, meta.decision, { by: by ?? process.env.MENTURA_PERSON ?? "founder", answer: picked, note: `accepted draft ${picked} of ${meta.route}` });
+  return { picked, decision: meta.decision, decided: d.ok, ...(d.ok ? {} : { error: d.error }) };
+}
+
+/** The drafts waiting in a venture: route, rule, owner and variants. A draft with no sidecar was held by its decision class. */
+export function inbox(dir, owner) {
+  const d = join(dir, "_drafts");
+  if (!existsSync(d)) return [];
+  return readdirSync(d).filter((f) => f.endsWith(".draft")).sort().map((f) => {
+    const draft = `_drafts/${f}`;
+    const meta = sidecar(dir, draft);
+    return { draft, file: f.replace(/\.draft$/, "").replace(/__/g, "/"), route: meta?.route ?? null, rule: meta?.rule ?? null, then: meta?.then ?? "draft",
+      owner: meta?.owner ?? null, variants: (meta?.variants ?? [{ variant: "a" }]).map((v) => v.variant), decision: meta?.decision ?? null };
+  }).filter((x) => !owner || x.owner === owner);
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const [dir] = process.argv.slice(2).filter((a, i, all) => !a.startsWith("--") && !(i && all[i - 1] === "--owner"));
+  if (!dir || !existsSync(join(dir, "venture.json"))) { console.error("usage: node schema/gate-drafts.mjs <venture dir> [--owner <role>] [--json]"); process.exit(2); }
+  const i = process.argv.indexOf("--owner");
+  const rows = inbox(dir, i > 0 ? process.argv[i + 1] : undefined);
+  if (process.argv.includes("--json")) console.log(JSON.stringify(rows, null, 2));
+  else if (!rows.length) console.log("no drafts waiting");
+  else for (const r of rows) console.log(`${r.file.padEnd(36)} ${r.then.padEnd(6)} ${r.owner ?? "-"}  ${r.rule ?? "decision class"}  variants ${r.variants.join(", ")}`);
+}

package/schema/gate.mjs

@@ -0,0 +1,133 @@
+// The gate (EE-073, P-5, X-1 to X-6): what happens to a write before it lands. One gate per venture
+// (X-5). Its rules come from three places: the venture's naive.config.json (fail_closed routes and
+// rules), each package's gate_rules in its package definition (imported, unless the config leaves a
+// package out), and two the framework always applies: pinned package versions (U-4) and the acting
+// role's write access (P-27). A rule names the routes it covers in the router's own path patterns
+// (X-6) and says what happens: hold the write as a draft, send it as a draft to the function owner
+// (X-2), or refuse it.
+//
+// The gate is fast and never calls a model (X-4). Confidence routing reads a score the write already
+// carries; a write without a score is never held for confidence. Access is checked here and again
+// at the record by the router, on every read and write (F-5). The gate decides; storing a held
+// write, and keeping differing drafts side by side, is schema/gate-drafts.mjs.
+
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { may } from "./access.mjs";
+import { configFor, functionOf, packageDefs, packagesOf, pinsBlocking, threshold } from "./naive-config.mjs";
+
+const repo = new URL("..", import.meta.url).pathname;
+
+/** Package gates, imported from packages/<name>/package.json: the completion gates, as written. 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 by fail_closed alone. fail_closed names path prefixes
+ * (foundation, or foundation/problem). A person is not held. Kept for callers of the first gate.
+ */
+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 gate section of the venture's naive.config.json, with its defaults. */
+export function configOf(dir) {
+  return configFor(dir).gate;
+}
+
+/**
+ * A route pattern as a regular expression, in the router's own path syntax (X-6): a plain route
+ * matches itself; an [id] (any [name]) segment or * is one segment; ** is any depth, and a trailing
+ * /** covers the route above it too (validation/** covers validation).
+ */
+export function patternRe(pattern) {
+  const segs = pattern.split("/").filter(Boolean);
+  let re = "", sep = false;
+  segs.forEach((s, i) => {
+    if (s === "**") {
+      if (i === segs.length - 1) re += sep ? "(?:/.*)?" : ".*";
+      else { re += sep ? "(?:/[^/]+)*/" : "(?:[^/]+/)*"; sep = false; }
+      return;
+    }
+    re += (sep ? "/" : "") + (/^\[[a-z.]+\]$/.test(s) || s === "*" ? "[^/]+" : s.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]*"));
+    sep = true;
+  });
+  return new RegExp(`^${re}$`);
+}
+
+/** Whether a rule's pattern covers a write: the concrete route (product/kettle) or its table route (product/[id]). */
+export function matches(pattern, route, tableRoute) {
+  const re = patternRe(pattern);
+  return re.test(route) || (!!tableRoute && (pattern === tableRoute || re.test(tableRoute)));
+}
+
+/** Gate rules imported from the package definitions (X-5): each package's gate_rules, tagged with the package. */
+export function packageRules(config) {
+  const sel = config?.gate?.packages ?? true;
+  if (sel === false) return [];
+  return packageDefs().filter((p) => sel === true || sel[p.name] !== false)
+    .flatMap((p) => (p.gate_rules ?? []).map((r) => ({ ...r, source: `package ${p.name}`, package: p.name })));
+}
+
+/** Every rule the venture's gate applies, in order: fail_closed, the config's rules, then the packages'. */
+export function rulesFor(config) {
+  const g = config?.gate ?? {};
+  return [
+    ...(g.fail_closed ?? []).map((p) => ({ id: p, routes: [p, `${p}/**`], then: "draft", actors: ["agent"], source: "naive.config.json", fail_closed: true })),
+    ...(g.rules ?? []).map((r) => ({ ...r, source: "naive.config.json" })),
+    ...packageRules(config),
+  ];
+}
+
+const SEVERITY = { pass: 0, draft: 1, owner: 2, refuse: 3 };
+
+/**
+ * The gate's verdict on one write. Input: config (resolved, from configFor), dir (for access),
+ * route (concrete), table (its route-table pattern), record (type), actor (person or agent), role
+ * (team-plan id), confidence (a score the write carries, or undefined), exists (the record exists
+ * now), decisionOwner (the owner of the record's decision class, if any).
+ * Returns { then: pass | draft | owner | refuse, rule, source, owner, variants, why, matched }.
+ */
+export function evaluate({ config, dir, route, table, requested, record, actor = "agent", role, confidence, exists, decisionOwner }) {
+  const pins = pinsBlocking(config, record);
+  if (pins.length) return { then: "refuse", rule: "pinned-version", source: "naive.config.json packages", matched: ["pinned-version"],
+    why: pins.map((p) => `${p.package} is pinned to ${p.pinned} but ${p.installed ?? "nothing"} is installed`).join("; ") + ": change the pin or the install first" };
+  if (dir && role && ![route, table, requested].some((x) => x && may(dir, role, "write", x)))
+    return { then: "refuse", rule: "access", source: "team plan", matched: ["access"], why: `${role} may not write ${route} (team plan routes)` };
+  const hits = [];
+  for (const r of rulesFor(config)) {
+    if (!(r.actors ?? ["agent"]).includes(actor)) continue;
+    if (r.roles?.length && !r.roles.includes(role)) continue;
+    if (!r.routes.some((p) => matches(p, route, table))) continue;
+    const w = r.when ?? {};
+    if (w.exists !== undefined && w.exists !== !!exists) continue;
+    if (w.confidence_below !== undefined) {
+      const limit = typeof w.confidence_below === "number" ? w.confidence_below : threshold(config, w.confidence_below, threshold(config, "confidence", 0.7));
+      if (typeof confidence !== "number" || confidence >= limit) continue;
+    }
+    hits.push(r);
+  }
+  if (!hits.length) return { then: "pass", rule: null, source: null, matched: [] };
+  const top = hits.reduce((a, b) => (SEVERITY[b.then] > SEVERITY[a.then] ? b : a));
+  const fn = functionOf(record);
+  // The owner: the rule's, else naive.config.json owners by function or by package, else the record's decision-class owner, else the founder.
+  const keys = [fn, top.package, ...packagesOf(record).map((p) => p.name)].filter(Boolean);
+  const owner = top.then === "owner" ? top.owner ?? keys.map((k) => config?.owners?.[k]).find(Boolean) ?? decisionOwner ?? "founder" : undefined;
+  const variants = !!(top.variants ?? config?.gate?.variants);
+  const where = top.fail_closed ? `${top.id} fails closed in naive.config.json` : `rule ${top.id} (${top.source})`;
+  const why = top.then === "refuse" ? `${where} refuses this write${top.note ? `: ${top.note}` : ""}`
+    : top.then === "owner" ? `${where} sends this write to its function owner, ${owner}: written as a draft for them to accept`
+    : `${where}: written as a draft for a person to accept`;
+  return { then: top.then, rule: top.id, source: top.source, ...(owner ? { owner, function: fn } : {}), variants, why, matched: hits.map((h) => h.id) };
+}

package/schema/glossary.schema.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "glossary.schema.json",
+  "title": "Package glossary",
+  "description": "A package's own terms, at glossary/<package>.json (Y-2, the scoping idea of CSS Modules): each term stays local to the package unless export is true, so an agent working in another package sees only exported terms. Two packages exporting one term with different meanings fail schema/check-brand.mjs. Version 0.x, unevaluated.",
+  "type": "object",
+  "required": ["package", "terms"],
+  "additionalProperties": false,
+  "properties": {
+    "package": { "type": "string", "pattern": "^[a-z0-9][a-z0-9-]*$", "description": "The package whose terms these are; the file is glossary/<package>.json" },
+    "terms": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": ["term", "meaning"],
+        "additionalProperties": false,
+        "properties": {
+          "term": { "type": "string", "minLength": 1 },
+          "meaning": { "type": "string", "minLength": 1 },
+          "export": { "type": "boolean", "description": "true: other packages see it too" }
+        }
+      }
+    }
+  }
+}

package/schema/handoff.schema.json

@@ -0,0 +1,239 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "handoff.schema.json",
+  "title": "Handoff",
+  "description": "One unit of delegated work, stored at <venture>/operations/handoffs/<id>.json (EE-017). It is the machine half of handoff contract v2 (operations/handoff-v2.md): who holds it, which decision rights it carries, how it is checked, and where it stands. The brief (outcome, work, context) is prose in a Markdown file beside it. schema/check-ready.mjs checks it is ready before work starts; schema/check-execution.mjs checks it against the venture's decision rights and evidence.",
+  "type": "object",
+  "required": [
+    "id",
+    "title",
+    "venture",
+    "role",
+    "brief",
+    "decision_classes",
+    "done_criteria",
+    "status",
+    "attempts",
+    "max_attempts",
+    "run_cap"
+  ],
+  "properties": {
+    "id": {
+      "type": "string",
+      "pattern": "^[a-z0-9-]+$"
+    },
+    "title": {
+      "type": "string"
+    },
+    "venture": {
+      "type": "string",
+      "description": "Venture id"
+    },
+    "products": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "description": "Product ids the work serves"
+    },
+    "governed_by": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "description": "Decision ids this executes (EE-NNN, G-NNN, D-NNN or an ADR path)"
+    },
+    "assignment": {
+      "type": "string",
+      "pattern": "^(A-[0-9]{3}|none)$",
+      "description": "Optional: the build-method assignment the work runs under, such as a MAD A-NNN, or none. MAD is a separate product, so Mentura records the reference and does not check it (EE-019, EE-038)"
+    },
+    "inputs": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "description": "Files the work needs before it can start, from the repo root; check-ready.mjs makes sure they exist"
+    },
+    "role": {
+      "type": "string",
+      "description": "Role id from the roles register that holds it (builder, architect and so on)"
+    },
+    "brief": {
+      "type": "string",
+      "description": "Path to the Markdown brief, relative to this file"
+    },
+    "decision_classes": {
+      "type": "array",
+      "minItems": 1,
+      "uniqueItems": true,
+      "items": {
+        "type": "string"
+      },
+      "description": "Decision-rights class ids the holder may use without reporting back. Anything outside them is escalated."
+    },
+    "done_criteria": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "required": [
+          "id",
+          "kind",
+          "check"
+        ],
+        "properties": {
+          "id": {
+            "type": "string",
+            "pattern": "^[a-z0-9-]+$"
+          },
+          "kind": {
+            "enum": [
+              "conformance",
+              "self-proof",
+              "review"
+            ],
+            "description": "conformance: an objective check run as a command, with no model and no reviewer. self-proof: the change exercised for real, with evidence attached (EE-006). review: fit to intent, judged by the named role."
+          },
+          "check": {
+            "type": "string",
+            "description": "The command to run, or for review the question the reviewer answers"
+          },
+          "reviewer": {
+            "type": "string",
+            "description": "Role id, for review criteria"
+          }
+        },
+        "additionalProperties": false
+      }
+    },
+    "status": {
+      "enum": [
+        "draft",
+        "ready",
+        "in-progress",
+        "escalated",
+        "done"
+      ],
+      "description": "draft until schema/check-ready.mjs passes and is recorded; then ready, in-progress, escalated or done"
+    },
+    "ready_check": {
+      "type": "object",
+      "required": [
+        "at",
+        "by",
+        "version",
+        "items"
+      ],
+      "properties": {
+        "at": {
+          "type": "string",
+          "format": "date-time"
+        },
+        "by": {
+          "type": "string"
+        },
+        "version": {
+          "type": "string"
+        },
+        "items": {
+          "type": "integer"
+        }
+      },
+      "description": "Written by check-ready.mjs --record when every readiness item passed, before execution started"
+    },
+    "claimed_by": {
+      "type": "string",
+      "description": "Session or run id of the holder"
+    },
+    "session_id": {
+      "type": "string",
+      "description": "Session that wrote the handoff"
+    },
+    "parent_session_id": {
+      "type": "string",
+      "description": "Session that assigned it, for lineage"
+    },
+    "attempts": {
+      "type": "integer",
+      "minimum": 0
+    },
+    "max_attempts": {
+      "type": "integer",
+      "minimum": 1,
+      "default": 3
+    },
+    "run_cap": {
+      "type": "string",
+      "pattern": "^([0-9]+(m|h)|\\$[0-9]+)$",
+      "description": "Wall-clock or spend cap per run, such as 2h or $20"
+    },
+    "pr": {
+      "type": "string",
+      "description": "Pull request link once opened"
+    },
+    "evidence": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "description": "Paths to eval or check results (evidence.schema.json) that prove the done-criteria"
+    },
+    "escalations": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": [
+          "class",
+          "question",
+          "to"
+        ],
+        "properties": {
+          "class": {
+            "type": "string",
+            "description": "The decision-rights class, or attempts or run-cap"
+          },
+          "question": {
+            "type": "string"
+          },
+          "to": {
+            "type": "string",
+            "description": "Role id"
+          },
+          "blocks": {
+            "type": "string"
+          },
+          "continued": {
+            "type": "string"
+          },
+          "answer": {
+            "type": "string"
+          }
+        },
+        "additionalProperties": false
+      }
+    },
+    "lesson": {
+      "type": "string",
+      "description": "A failure that could recur, and the check one rung higher that would catch it (prose, skill, rule, static analysis, code)"
+    },
+    "publication": {
+      "type": "object",
+      "description": "Required when the handoff publishes (public-commitment in decision_classes or escalations): the channel and content rule in the venture's publication policy (EE-025)",
+      "required": [
+        "channel",
+        "content"
+      ],
+      "additionalProperties": false,
+      "properties": {
+        "channel": {
+          "type": "string"
+        },
+        "content": {
+          "type": "string"
+        }
+      }
+    }
+  },
+  "additionalProperties": false
+}