naive-framework 0.0.0-stage → 0.2.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/frames/judge.mjs

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+// A stand-in judge for the frames test (the Jev protocol): reads one request on stdin and answers every
+// noul question from the facts it was given, without a model. A premise is unknown (0.5) when a fact it
+// could rest on says "not on record", else no (0.1); the trade reads as a sequence.
+let input = "";
+for await (const c of process.stdin) input += c;
+const req = JSON.parse(input);
+const unknown = Object.values(req.state.venture ?? {}).some((v) => v === "not on record");
+const answers = Object.fromEntries(Object.keys(req.questions).map((k) => [k, { noul: k.startsWith("dichotomy:") ? (k === "dichotomy:sequence" ? 0.9 : 0.1) : k === "premise:needs-outside-money" && unknown ? 0.5 : 0.1 }]));
+console.log(JSON.stringify({ model: "stand-in", answers }));

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/venture-type/jev.mjs

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+// A stand-in for Jev in tests (MENTURA_TYPE_CMD="node schema/examples/venture-type/jev.mjs"): reads the
+// typed request on stdin and answers each type:<id> question yes when the description uses one of that
+// type's examples, so the classifier's ranking and its uncertain path can be tested offline.
+import { readFileSync } from "node:fs";
+let input = "";
+for await (const c of process.stdin) input += c;
+const req = JSON.parse(input);
+const words = req.state.venture.description.toLowerCase();
+const types = JSON.parse(readFileSync(new URL("../../venture-types.json", import.meta.url), "utf8")).types;
+const answers = Object.fromEntries(types.map((t) => [`type:${t.id}`, { noul: t.examples.some((e) => words.includes(e.toLowerCase())) ? 0.92 : 0.04 }]));
+console.log(JSON.stringify({ model: "stand-in", answers }));

package/schema/examples/workspace/ventures/acme-labs/AGENTS.md

@@ -0,0 +1,17 @@
+# AGENTS.md: acme-labs
+
+The map of this venture for agents. Read it, then a route's layout, before writing anything here.
+
+## How to work here
+
+- List the routes with `mentura routes`. Read a route's `layout` and `template` before you write to it.
+- Write through the router (the CLI or the MCP server), not by editing files. Every write is checked against its schema and recorded in provenance.jsonl.
+- A write that fails closed comes back as a draft in `_drafts/`. A person accepts it with `mentura accept`.
+- Never read or send anything under `_private/` to a model.
+- A deeper AGENTS.md (for example `marketing/AGENTS.md`) adds to this one for the routes under it; the nearer one wins.
+
+## Instructions
+
+phase: discovery
+voice: plain words, in the founder's own terms
+private: _private/

package/schema/examples/workspace/ventures/acme-labs/decisions/discovery-goal.decision.json

@@ -0,0 +1,23 @@
+{
+  "id": "discovery-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",
+  "status": "decided",
+  "provenance": {
+    "drafted_by": {
+      "kind": "agent"
+    },
+    "approved_by": "Maya Chen",
+    "approved_at": "2026-10-29T06:29:13Z",
+    "phase": "discovery",
+    "wording": "own",
+    "via": "api"
+  },
+  "answer": "Ten cafe owners confirm the reordering problem in interviews, and three agree to pilot the app, by the end of December."
+}

package/schema/examples/workspace/ventures/acme-labs/decisions/statement-icp.decision.json

@@ -0,0 +1,22 @@
+{
+  "id": "statement-icp",
+  "question": "Write the icp statement",
+  "statement": "icp",
+  "decides": {
+    "record": "icp"
+  },
+  "layer": "purpose",
+  "needed_in": "discovery",
+  "status": "decided",
+  "provenance": {
+    "drafted_by": {
+      "kind": "agent"
+    },
+    "approved_by": "Maya Chen",
+    "approved_at": "2026-10-29T06:29:12Z",
+    "phase": "discovery",
+    "wording": "own",
+    "via": "api"
+  },
+  "answer": "Owner-operators of one to three independent cafes in one city, who order from three or more suppliers."
+}

package/schema/examples/workspace/ventures/acme-labs/decisions/statement-problem.decision.json

@@ -0,0 +1,22 @@
+{
+  "id": "statement-problem",
+  "question": "Write the problem statement",
+  "statement": "problem",
+  "decides": {
+    "record": "validation-problem"
+  },
+  "layer": "purpose",
+  "needed_in": "discovery",
+  "status": "decided",
+  "provenance": {
+    "drafted_by": {
+      "kind": "agent"
+    },
+    "approved_by": "Maya Chen",
+    "approved_at": "2026-10-29T06:29:12Z",
+    "phase": "discovery",
+    "wording": "own",
+    "via": "api"
+  },
+  "answer": "Independent cafe owners lose three to five hours a week reordering supplies by hand, and still run out of best-sellers."
+}

package/schema/examples/workspace/ventures/acme-labs/decisions/venture.team.decision.json

@@ -0,0 +1,37 @@
+{
+  "id": "founding-team",
+  "question": "Who is founding this venture: you alone, you with cofounders, or you looking for cofounders?",
+  "decides": {
+    "record": "founder-agreement",
+    "path": "governance/founder-agreement.json"
+  },
+  "layer": "governance",
+  "boundary": "fail-open",
+  "needed_in": "discovery",
+  "status": "decided",
+  "options": [
+    "Solo: I am founding it alone",
+    "Cofounders: we are founding it together",
+    "Looking: I want cofounders"
+  ],
+  "unlocks": [
+    {
+      "activity": "Draft the founder agreement with the founding-agreement kit",
+      "routes": [
+        "governance/founder-agreement"
+      ]
+    }
+  ],
+  "provenance": {
+    "drafted_by": {
+      "kind": "framework",
+      "id": "naive"
+    },
+    "approved_by": "Maya Chen",
+    "approved_at": "2026-10-29T06:29:12Z",
+    "phase": "discovery",
+    "wording": "own",
+    "via": "api"
+  },
+  "answer": "Solo: I am founding it alone"
+}

package/schema/examples/workspace/ventures/acme-labs/knowledge/README.md

@@ -0,0 +1,3 @@
+# knowledge
+
+Memory: every record the venture keeps, including notes, specs, decisions and references.

package/schema/examples/workspace/ventures/acme-labs/knowledge/sources.json

@@ -0,0 +1,46 @@
+{
+  "sources": [],
+  "records": {},
+  "truth": "local",
+  "functions": {
+    "products": {
+      "systems": [
+        {
+          "system": "local-repo",
+          "address": "../acme-app",
+          "status": "pointed"
+        },
+        {
+          "system": "github",
+          "address": "acme-labs/app",
+          "status": "pointed"
+        },
+        {
+          "system": "vercel",
+          "address": "acme-labs/web",
+          "status": "pointed"
+        }
+      ]
+    },
+    "marketing-and-sales": {
+      "systems": [
+        {
+          "system": "vercel",
+          "address": "acme-labs/web",
+          "status": "pointed"
+        }
+      ]
+    },
+    "finance": {
+      "systems": [
+        {
+          "system": "rho",
+          "status": "connected",
+          "synced": "2026-10-29T06:28:55Z",
+          "fixture": true,
+          "address": "saved sandbox answer"
+        }
+      ]
+    }
+  }
+}

package/schema/examples/workspace/ventures/acme-labs/money/30000000-0000-4000-8000-000000000001.json

@@ -0,0 +1,12 @@
+{
+  "id": "30000000-0000-4000-8000-000000000001",
+  "name": "Reserve Checking",
+  "type": "checking",
+  "last_4": "0106",
+  "balance": {
+    "amount": 1046,
+    "currency": "USD"
+  },
+  "source": "rho-sandbox:account:30000000-0000-4000-8000-000000000001",
+  "synced_at": "2026-10-29T06:34:34.210Z"
+}

package/schema/examples/workspace/ventures/acme-labs/money/30000000-0000-4000-8000-000000000002.json

@@ -0,0 +1,12 @@
+{
+  "id": "30000000-0000-4000-8000-000000000002",
+  "name": "Cash (Checking)",
+  "type": "checking",
+  "last_4": "9508",
+  "balance": {
+    "amount": 876138,
+    "currency": "USD"
+  },
+  "source": "rho-sandbox:account:30000000-0000-4000-8000-000000000002",
+  "synced_at": "2026-10-29T06:34:34.210Z"
+}

package/schema/examples/workspace/ventures/acme-labs/money/30000000-0000-4000-8000-000000000003.json

@@ -0,0 +1,12 @@
+{
+  "id": "30000000-0000-4000-8000-000000000003",
+  "name": "Cash (Checking)",
+  "type": "checking",
+  "last_4": "4609",
+  "balance": {
+    "amount": 8711697,
+    "currency": "USD"
+  },
+  "source": "rho-sandbox:account:30000000-0000-4000-8000-000000000003",
+  "synced_at": "2026-10-29T06:34:34.210Z"
+}

package/schema/examples/workspace/ventures/acme-labs/money/30000000-0000-4000-8000-000000000004.json

@@ -0,0 +1,12 @@
+{
+  "id": "30000000-0000-4000-8000-000000000004",
+  "name": "Treasury Checking",
+  "type": "checking",
+  "last_4": "7301",
+  "balance": {
+    "amount": 15460929,
+    "currency": "USD"
+  },
+  "source": "rho-sandbox:account:30000000-0000-4000-8000-000000000004",
+  "synced_at": "2026-10-29T06:34:34.210Z"
+}

package/schema/examples/workspace/ventures/acme-labs/money/30000000-0000-4000-8000-000000000005.json

@@ -0,0 +1,12 @@
+{
+  "id": "30000000-0000-4000-8000-000000000005",
+  "name": "Inventory Checking",
+  "type": "checking",
+  "last_4": "3608",
+  "balance": {
+    "amount": 0,
+    "currency": "USD"
+  },
+  "source": "rho-sandbox:account:30000000-0000-4000-8000-000000000005",
+  "synced_at": "2026-10-29T06:34:34.210Z"
+}

package/schema/examples/workspace/ventures/acme-labs/money/30000000-0000-4000-8000-000000000006.json

@@ -0,0 +1,12 @@
+{
+  "id": "30000000-0000-4000-8000-000000000006",
+  "name": "Primary Checking",
+  "type": "checking",
+  "last_4": "5702",
+  "balance": {
+    "amount": 811970,
+    "currency": "USD"
+  },
+  "source": "rho-sandbox:account:30000000-0000-4000-8000-000000000006",
+  "synced_at": "2026-10-29T06:34:34.210Z"
+}

package/schema/examples/workspace/ventures/acme-labs/money/30000000-0000-4000-8000-000000000007.json

@@ -0,0 +1,12 @@
+{
+  "id": "30000000-0000-4000-8000-000000000007",
+  "name": "Credit Account",
+  "type": "credit",
+  "last_4": null,
+  "balance": {
+    "amount": 0,
+    "currency": "USD"
+  },
+  "source": "rho-sandbox:account:30000000-0000-4000-8000-000000000007",
+  "synced_at": "2026-10-29T06:34:34.210Z"
+}

package/schema/examples/workspace/ventures/acme-labs/money/30000000-0000-4000-8000-000000000008.json

@@ -0,0 +1,12 @@
+{
+  "id": "30000000-0000-4000-8000-000000000008",
+  "name": "Credit Account",
+  "type": "credit",
+  "last_4": null,
+  "balance": {
+    "amount": 0,
+    "currency": "USD"
+  },
+  "source": "rho-sandbox:account:30000000-0000-4000-8000-000000000008",
+  "synced_at": "2026-10-29T06:34:34.210Z"
+}

package/schema/examples/workspace/ventures/acme-labs/money/30000000-0000-4000-8000-000000000009.json

@@ -0,0 +1,12 @@
+{
+  "id": "30000000-0000-4000-8000-000000000009",
+  "name": "Credit Account",
+  "type": "credit",
+  "last_4": null,
+  "balance": {
+    "amount": 0,
+    "currency": "USD"
+  },
+  "source": "rho-sandbox:account:30000000-0000-4000-8000-000000000009",
+  "synced_at": "2026-10-29T06:34:34.210Z"
+}

package/schema/examples/workspace/ventures/acme-labs/money/30000000-0000-4000-8000-000000000010.json

@@ -0,0 +1,12 @@
+{
+  "id": "30000000-0000-4000-8000-000000000010",
+  "name": "Credit Account",
+  "type": "credit",
+  "last_4": null,
+  "balance": {
+    "amount": 0,
+    "currency": "USD"
+  },
+  "source": "rho-sandbox:account:30000000-0000-4000-8000-000000000010",
+  "synced_at": "2026-10-29T06:34:34.210Z"
+}