naive-framework 0.0.0-stage → 0.1.0

package/purpose/frameworks/idea-map/graph.mjs

@@ -0,0 +1,182 @@
+#!/usr/bin/env node
+// The idea graph (EE-060): the step after the idea map in the pipeline dump -> map -> graph -> roadmap.
+// The dump and the map stay loose; the graph is the first structured form. It is a Merkle DAG: an
+// idea builds on the ideas that must be worked out before it, and its id is a hash of its text and
+// the hashes of those ideas, so a change upstream changes every id downstream, as in git. The graph
+// has no decisions in it; decisions come later, from what it shows.
+//
+// From the graph:
+//   - signal: how much each idea is worth developing next (graph.json `signal`, version 0.x, ours and
+//     unevaluated): what the venture's phase needs of the records it feeds, how much builds on it,
+//     how concrete it is, and how much of the dump circles it;
+//   - lanes: ideas tied by dependencies form one lane and move in order (synchronous); a lane with no
+//     tie to another moves on its own (asynchronous) and can run beside it;
+//   - layout: left to right by dependency depth, lanes and ideas top down by signal.
+//
+// Dependencies come from Jev (one typed question per ordered pair of ideas) when the platform hands
+// over its answers; otherwise from Naive's convention of which records build on which.
+//
+//   node graph.mjs request <venture>                  the Jev request (pairs and concreteness)
+//   node graph.mjs build <venture> [<answers.json>]   writes purpose/ideas/graph.json
+//   node graph.mjs <venture> [--json]                  summary of the graph
+
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { CONVENTIONS, MAP, parse } from "./ideamap.mjs";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const repo = join(here, "../../..");
+const load = (p) => JSON.parse(readFileSync(p, "utf8"));
+export const GRAPH = "purpose/ideas/graph.json";
+const NEED = load(join(repo, "schema/need-now.json")).records;
+
+// Naive's convention of which records build on which, used when no judge has answered. An idea that
+// feeds a later record builds on an idea that feeds an earlier one in the same department.
+export const ORDER = ["telos", "validation-problem", "icp", "venture-core", "validation-solution", "product", "validation-pricing", "validation-go-to-market", "brand", "validation-team", "alignment"];
+const EXTRA_NEED = { "venture-core": { discovery: 0.8, validation: 0.9, beachhead: 0.9, scale: 0.9, platform: 0.9 }, brand: { discovery: 0.2, validation: 0.4, beachhead: 0.7, scale: 0.8, platform: 0.8 } };
+export const WEIGHTS = { need: 0.35, unblocks: 0.25, concrete: 0.25, emphasis: 0.15 };
+// Jev answers dependency questions conservatively (in our first runs few pairs passed 0.75), so the bar is 0.5.
+const THRESHOLD = 0.5;
+
+const CONCRETE = ["A wish or a theme: nothing anyone could act on yet", "A direction: it names what, but not how or for whom", "A plan: someone could start on it with a few questions answered", "Actionable now: someone could act on it this week as written"];
+
+/** The Jev request: for each ordered pair, whether one idea must be worked out first; and how concrete each is. */
+export function request(ideas, venture = {}) {
+  const questions = {};
+  for (const a of ideas) for (const b of ideas) if (a.id !== b.id)
+    questions[`dep:${a.id}>${b.id}`] = { type: "noul", instructions: `Does developing the idea in \`ideas.${b.id}\` depend on the idea in \`ideas.${a.id}\` being worked out first (it builds on it, needs its answer, or makes no sense without it)?`,
+      criteria: { true: "Yes: it builds directly on that idea", false: "No: it could be developed without it" } };
+  for (const i of ideas) questions[`concrete:${i.id}`] = { type: "score", instructions: `How concrete is the idea in \`ideas.${i.id}\`?`, criteria: CONCRETE };
+  return { state: { venture: { id: venture.id, phase: venture.phase }, guidelines: CONVENTIONS.guidelines.graph, ideas: Object.fromEntries(ideas.map((i) => [i.id, i.section ? `[${i.section}] ${i.text}` : i.text])) }, model: "jev-latest", questions };
+}
+
+/** Dependencies by convention: b builds on a when a feeds an earlier record and they share a department. */
+export function conventionEdges(ideas) {
+  const rank = (i) => Math.min(...(i.records ?? []).map((r) => ORDER.indexOf(r)).filter((x) => x >= 0), 99);
+  const edges = [];
+  for (const a of ideas) for (const b of ideas) {
+    if (a.id === b.id || rank(a) >= rank(b) || rank(a) === 99) continue;
+    if ((a.departments ?? []).some((d) => (b.departments ?? []).includes(d))) edges.push({ from: a.id, to: b.id, p: 0.8, by: "convention" });
+  }
+  return edges;
+}
+
+// Keeps the graph a DAG: edges are added strongest first, and one that would close a cycle is dropped.
+function acyclic(ids, edges) {
+  const out = new Map(ids.map((i) => [i, new Set()]));
+  const reaches = (from, to) => { const seen = new Set(), stack = [from]; while (stack.length) { const x = stack.pop(); if (x === to) return true; if (seen.has(x)) continue; seen.add(x); stack.push(...out.get(x)); } return false; };
+  const kept = [], dropped = [];
+  for (const e of [...edges].sort((a, b) => b.p - a.p)) {
+    if (reaches(e.to, e.from)) { dropped.push(e); continue; }
+    out.get(e.from).add(e.to); kept.push(e);
+  }
+  // Transitive reduction: a -> c goes when a -> b -> c already says it.
+  const reduced = kept.filter((e) => ![...out.get(e.from)].some((m) => m !== e.to && reaches(m, e.to)));
+  return { edges: reduced, dropped };
+}
+
+const sha = (s) => createHash("sha256").update(s).digest("hex");
+
+/** The Merkle DAG with signal, lanes and layout. */
+export function build(ideas, { answers = null, phase = "discovery", venture, source } = {}) {
+  const ids = ideas.map((i) => i.id);
+  let raw = [], concrete = {};
+  if (answers) {
+    for (const [k, a] of Object.entries(answers)) {
+      if (k.startsWith("dep:")) { const [from, to] = k.slice(4).split(">"); const p = typeof a.noul === "number" ? a.noul : a.noul === true ? 1 : 0; if (p >= THRESHOLD) raw.push({ from, to, p: Math.round(p * 100) / 100, by: "jev" }); }
+      else if (k.startsWith("concrete:")) concrete[k.slice(9)] = typeof a.score === "number" ? a.score / (CONCRETE.length - 1) : null;
+    }
+  } else raw = conventionEdges(ideas);
+  const { edges, dropped } = acyclic(ids, raw);
+  const parents = new Map(ids.map((i) => [i, edges.filter((e) => e.to === i).map((e) => e.from)]));
+  const children = new Map(ids.map((i) => [i, edges.filter((e) => e.from === i).map((e) => e.to)]));
+
+  // Topological order, depth (longest path from a root) and Merkle hashes.
+  const order = [], depth = {}, hash = {};
+  const indeg = new Map(ids.map((i) => [i, parents.get(i).length]));
+  const queue = ids.filter((i) => !indeg.get(i));
+  while (queue.length) { const x = queue.shift(); order.push(x); for (const c of children.get(x)) { indeg.set(c, indeg.get(c) - 1); if (!indeg.get(c)) queue.push(c); } }
+  const byId = Object.fromEntries(ideas.map((i) => [i.id, i]));
+  for (const x of order) {
+    depth[x] = Math.max(-1, ...parents.get(x).map((p) => depth[p])) + 1;
+    hash[x] = sha(JSON.stringify({ text: byId[x].text, parents: parents.get(x).map((p) => hash[p]).sort() })).slice(0, 16);
+  }
+  const descendants = (x, seen = new Set()) => { for (const c of children.get(x)) if (!seen.has(c)) { seen.add(c); descendants(c, seen); } return seen; };
+
+  // Signal (version 0.x): need of the records it feeds in this phase, what builds on it, how concrete
+  // it is, and how much of the dump shares its department.
+  const need = (r) => (NEED[r]?.base ?? EXTRA_NEED[r])?.[phase] ?? 0;
+  const deptCount = {};
+  for (const i of ideas) for (const d of i.departments ?? []) deptCount[d] = (deptCount[d] ?? 0) + 1;
+  const maxDesc = Math.max(1, ...ids.map((x) => descendants(x).size));
+  const maxDept = Math.max(1, ...Object.values(deptCount));
+  const nodes = ids.map((x) => {
+    const i = byId[x];
+    const parts = {
+      need: Math.max(0, ...(i.records ?? []).map(need)),
+      unblocks: descendants(x).size / maxDesc,
+      concrete: concrete[x] ?? (i.exists ? 1 : 0.5),
+      emphasis: Math.max(0, ...(i.departments ?? []).map((d) => deptCount[d] / maxDept)),
+    };
+    const signal = Object.entries(WEIGHTS).reduce((s, [k, w]) => s + w * parts[k], 0);
+    return { id: x, hash: hash[x], text: i.text, ...(i.section ? { section: i.section } : {}), pillar: i.pillar, departments: i.departments ?? [], records: i.records ?? [], exists: !!i.exists,
+      depth: depth[x], builds_on: parents.get(x), signal: Math.round(signal * 100) / 100, parts: Object.fromEntries(Object.entries(parts).map(([k, v]) => [k, Math.round(v * 100) / 100])) };
+  });
+
+  // Lanes: the weakly connected parts of the DAG. A lane with dependencies is synchronous inside; lanes
+  // are asynchronous to each other. Lanes and their ideas are ordered by signal.
+  const lane = {}, lanes = [];
+  for (const x of ids) {
+    if (lane[x] !== undefined) continue;
+    const members = [], stack = [x];
+    while (stack.length) { const y = stack.pop(); if (lane[y] !== undefined) continue; lane[y] = lanes.length; members.push(y); stack.push(...parents.get(y), ...children.get(y)); }
+    lanes.push(members);
+  }
+  const nodeOf = Object.fromEntries(nodes.map((n) => [n.id, n]));
+  const top = (ms) => Math.max(...ms.map((m) => nodeOf[m].signal));
+  const ranked = lanes.map((ms) => ms.sort((a, b) => nodeOf[a].depth - nodeOf[b].depth || nodeOf[b].signal - nodeOf[a].signal)).sort((a, b) => top(b) - top(a) || b.length - a.length);
+  const laneOut = ranked.map((ms, k) => {
+    const depts = {}; for (const m of ms) for (const d of nodeOf[m].departments.slice(0, 1)) depts[d] = (depts[d] ?? 0) + 1;
+    const id = `lane-${k + 1}`;
+    for (const m of ms) nodeOf[m].lane = id;
+    return { id, mode: ms.length > 1 ? "sync" : "async", ideas: ms, department: Object.entries(depts).sort((a, b) => b[1] - a[1])[0]?.[0] ?? null, signal: top(ms),
+      why: ms.length > 1 ? `${ms.length} ideas that build on each other: they move in order` : "stands alone: it can move on its own, beside the other lanes" };
+  });
+  const sinks = nodes.filter((n) => !children.get(n.id).length).map((n) => n.hash).sort();
+  return {
+    version: "0.1.0", venture, phase, created: new Date().toISOString().replace(/\.\d+Z$/, "Z"), source,
+    root: sha(sinks.join("")).slice(0, 16), judged_by: answers ? "jev" : "convention", weights: WEIGHTS,
+    nodes: nodes.sort((a, b) => b.signal - a.signal), edges, dropped, lanes: laneOut,
+    next: nodes.filter((n) => n.depth === 0).sort((a, b) => b.signal - a.signal).slice(0, 3).map((n) => n.id),
+  };
+}
+
+/** Which ideas changed between two graphs: a changed hash means the idea or something it builds on changed. */
+export function diff(a, b) {
+  const A = new Map(a.nodes.map((n) => [n.id, n.hash])), B = new Map(b.nodes.map((n) => [n.id, n.hash]));
+  return { changed: [...B].filter(([id, h]) => A.has(id) && A.get(id) !== h).map(([id]) => id), added: [...B.keys()].filter((id) => !A.has(id)), removed: [...A.keys()].filter((id) => !B.has(id)) };
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const [a, b, c] = process.argv.slice(2);
+  const venture = (d) => load(join(d, "venture.json"));
+  const mapOf = (d) => parse(readFileSync(join(d, MAP), "utf8"));
+  if (a === "request") console.log(JSON.stringify(request(mapOf(b).ideas, venture(b))));
+  else if (a === "build") {
+    const answers = c ? (load(c).answers ?? load(c)) : null;
+    const g = build(mapOf(b).ideas, { answers, phase: venture(b).phase, venture: venture(b).id, source: `${MAP}@${sha(readFileSync(join(b, MAP), "utf8")).slice(0, 16)}` });
+    writeFileSync(join(b, GRAPH), JSON.stringify(g, null, 2) + "\n");
+    console.log(`wrote ${GRAPH}: ${g.nodes.length} ideas, ${g.edges.length} dependencies, ${g.lanes.filter((l) => l.mode === "sync").length} sync lanes, ${g.lanes.filter((l) => l.mode === "async").length} async; root ${g.root}`);
+  } else if (a && existsSync(join(a, "venture.json"))) {
+    if (!existsSync(join(a, GRAPH))) { console.error(`${GRAPH} does not exist yet: build it from the idea map (node graph.mjs build <venture>)`); process.exit(1); }
+    const g = load(join(a, GRAPH));
+    if (process.argv.includes("--json")) console.log(JSON.stringify(g, null, 2));
+    else {
+      console.log(`${g.nodes.length} ideas, ${g.edges.length} dependencies (${g.judged_by}), root ${g.root}`);
+      for (const l of g.lanes) console.log(`${l.id} ${l.mode.padEnd(5)} ${String(l.signal).padEnd(4)} ${l.department ?? ""}: ${l.ideas.join(" -> ")}`);
+      console.log(`Highest signal to develop next: ${g.next.join(", ")}`);
+    }
+  } else { console.error("usage: node graph.mjs request <venture> | build <venture> [<answers.json>] | <venture> [--json]"); process.exit(2); }
+}

package/purpose/frameworks/idea-map/ideamap.mjs

@@ -0,0 +1,179 @@
+#!/usr/bin/env node
+// The idea map (EE-059): a founder's raw idea dump, mapped onto Naive's conventions. The dump is not
+// a prompt; it is every idea the founder has about the venture, kept verbatim in
+// purpose/ideas/dump.md. Naive splits it into ideas, a tagger (Jev, or the founder's own agent) tags
+// each with the departments it bears on, the records it feeds and whether it already exists
+// (conventions.json), and the result is purpose/ideas/map.mdx: one <Idea> per idea, its text
+// unchanged. The canvas (interface/demo/board.mjs, /map) draws it as a mind map; the summary says
+// where the founder's ideas cluster, what the venture's phase needs that the dump never mentions,
+// and what the dump says about whether a product exists.
+//
+//   node ideamap.mjs <venture> [--json]               summary of purpose/ideas/map.mdx
+//   node ideamap.mjs split <dump.md>                   the ideas Naive reads in a dump
+//   node ideamap.mjs request <venture>                 the Jev request for the venture's dump
+//   node ideamap.mjs answers <venture> <answers.json>  Jev's answers to tags (prints tags JSON)
+//   node ideamap.mjs write <venture> <tags.json> --tagger <name>   writes map.mdx
+//
+// The tagger never rewrites an idea and never adds one; tags outside conventions.json are dropped.
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const repo = join(here, "../../..");
+const load = (p) => JSON.parse(readFileSync(p, "utf8"));
+export const CONVENTIONS = load(join(here, "conventions.json"));
+const DEPARTMENTS = load(join(repo, "operations/departments.json")).departments;
+export const DUMP = "purpose/ideas/dump.md", MAP = "purpose/ideas/map.mdx";
+const pillarOf = Object.fromEntries(Object.entries(CONVENTIONS.pillars).flatMap(([p, ds]) => ds.map((d) => [d, p])));
+
+/** The ideas in a raw dump:  each bullet or numbered line is one idea; any other line is its
+ *  own idea too, unless it continues a hard-wrapped line, and a long one splits into sentences. Headings name the section that follows. */
+export function split(text) {
+  const ideas = [];
+  let section = null, para = null;
+  const push = (t, line) => {
+    const clean = t.replace(/\s+/g, " ").trim();
+    if (!clean) return;
+    const parts = clean.length > 200 ? clean.match(/[^.!?]+(?:[.!?]+["')\]]*|$)\s*/g).reduce((acc, s) => {
+      if (acc.length && (acc.at(-1) + s).length < 160) acc[acc.length - 1] += s; else acc.push(s);
+      return acc;
+    }, []) : [clean];
+    for (const p of parts.map((x) => x.trim()).filter(Boolean)) ideas.push({ id: `i-${String(ideas.length + 1).padStart(2, "0")}`, line, ...(section ? { section } : {}), text: p });
+  };
+  const flush = () => { if (para) push(para.text, para.line); para = null; };
+  text.split(/\r?\n/).forEach((raw, i) => {
+    const line = raw.trim();
+    if (!line) return flush();
+    const h = line.match(/^#{1,6}\s+(.*)$/);
+    if (h) { flush(); section = h[1].trim(); return; }
+    const b = line.match(/^(?:[-*+•]|\d+[.)])\s+(.*)$/);
+    if (b) { flush(); push(b[1], i + 1); return; }
+    // A line is its own idea unless it continues a hard-wrapped one: the line before ran long with no
+    // closing punctuation and this one starts in lower case.
+    if (para && para.last.length > 60 && !/[.!?:;)"']$/.test(para.last) && /^[a-z]/.test(line)) { para.text += ` ${line}`; para.last = line; return; }
+    flush(); para = { text: line, line: i + 1, last: line };
+  });
+  flush();
+  return ideas;
+}
+
+/** One typed request for Jev: for each idea, a yes-no-unknown judgment per department, per record,
+ *  and whether it already exists. Jev answers each with a probability. */
+export function request(ideas, venture = {}) {
+  const questions = {};
+  const ask = (key, id, about) => { questions[`${key}:${id}`] = { type: "noul", instructions: `Is the idea in \`ideas.${id}\` mainly about ${about}?`, criteria: { true: "Yes: this is one of the one or two things the idea is mainly about", false: "No: it is about this only in passing, or not at all" } }; };
+  for (const i of ideas) {
+    for (const [d, about] of Object.entries(CONVENTIONS.departments)) ask(`dept.${d}`, i.id, about);
+    for (const [r, { about }] of Object.entries(CONVENTIONS.records)) ask(`rec.${r}`, i.id, about);
+    questions[`exists:${i.id}`] = { type: "noul", instructions: `Does the idea in \`ideas.${i.id}\` say that ${CONVENTIONS.exists}?`, criteria: { true: "Yes: it says this exists now", false: "No: it is planned, wished for or unclear" } };
+  }
+  return { state: { venture: { id: venture.id, phase: venture.phase }, guidelines: { dump: CONVENTIONS.guidelines.dump, tags: CONVENTIONS.guidelines.tags }, ideas: Object.fromEntries(ideas.map((i) => [i.id, i.section ? `[${i.section}] ${i.text}` : i.text])) }, model: "jev-latest", questions };
+}
+
+/** Jev's answers as tags: every judgment at or above the threshold, with the weakest one kept as confidence. */
+export function fromAnswers(answers, threshold = CONVENTIONS.threshold) {
+  const tags = {};
+  for (const [key, a] of Object.entries(answers)) {
+    const [q, id] = key.split(":");
+    const p = typeof a.noul === "number" ? a.noul : a.noul === true ? 1 : 0;
+    const t = (tags[id] ??= { departments: [], records: [], exists: false, scores: {} });
+    t.scores[q] = Math.round(p * 100) / 100;
+    if (p < threshold) continue;
+    if (q.startsWith("dept.")) t.departments.push(q.slice(5));
+    else if (q.startsWith("rec.")) t.records.push(q.slice(4));
+    else if (q === "exists") t.exists = true;
+  }
+  for (const t of Object.values(tags)) {
+    const strongest = (prefix) => Object.entries(t.scores).filter(([k]) => k.startsWith(prefix)).sort((a, b) => b[1] - a[1]);
+    // An idea always sits somewhere on the map: below the threshold it takes its likeliest department.
+    if (!t.departments.length) { const [k] = strongest("dept.")[0] ?? []; if (k) t.departments.push(k.slice(5)), t.tentative = true; }
+    t.departments = t.departments.sort((a, b) => t.scores[`dept.${b}`] - t.scores[`dept.${a}`]).slice(0, CONVENTIONS.max.departments);
+    t.records = t.records.sort((a, b) => t.scores[`rec.${b}`] - t.scores[`rec.${a}`]).slice(0, CONVENTIONS.max.records);
+  }
+  return tags;
+}
+
+/** Tags limited to the conventions, with each idea's pillar from its first department. */
+export function clean(tags) {
+  const out = {};
+  for (const [id, t] of Object.entries(tags ?? {})) {
+    const departments = (t.departments ?? []).filter((d) => d in CONVENTIONS.departments);
+    const records = (t.records ?? []).filter((r) => r in CONVENTIONS.records);
+    out[id] = { departments, records, exists: t.exists === true, pillar: pillarOf[departments[0]] ?? null, ...(t.tentative ? { tentative: true } : {}) };
+  }
+  return out;
+}
+
+const attr = (v) => typeof v === "string" ? JSON.stringify(v) : `{${JSON.stringify(v)}}`;
+const esc = (s) => s.replace(/[{}<>]/g, (c) => ({ "{": "&#123;", "}": "&#125;", "<": "&lt;", ">": "&gt;" }[c]));
+const unesc = (s) => s.replace(/&#123;|&#125;|&lt;|&gt;/g, (c) => ({ "&#123;": "{", "&#125;": "}", "&lt;": "<", "&gt;": ">" }[c]));
+
+/** map.mdx: frontmatter, then one <Idea> per idea, text verbatim, tags as props. */
+export function render(ideas, tags, { venture, tagger, created = new Date().toISOString().replace(/\.\d+Z$/, "Z") }) {
+  const t = clean(tags);
+  const head = ["---", "type: idea-map", `venture: ${venture}`, `created: ${created}`, `source: ${DUMP}`, `tagged_by: ${tagger}`, `conventions: purpose/frameworks/idea-map/conventions.json@${CONVENTIONS.version}`, "---", "",
+    `{/* Generated by Naive from ${DUMP}. Each idea is the founder's text, unchanged; the props are tags from Naive's conventions. */}`, ""];
+  const body = ideas.map((i) => {
+    const x = t[i.id] ?? { departments: [], records: [], exists: false, pillar: null };
+    const props = { id: i.id, line: i.line, ...(i.section ? { section: i.section } : {}), pillar: x.pillar ?? "unmapped", departments: x.departments, records: x.records, exists: x.exists, ...(x.tentative ? { tentative: true } : {}) };
+    return `<Idea ${Object.entries(props).map(([k, v]) => `${k}=${attr(v)}`).join(" ")}>\n${esc(i.text)}\n</Idea>\n`;
+  });
+  return head.join("\n") + body.join("\n");
+}
+
+/** The ideas and their tags back out of map.mdx. */
+export function parse(mdx) {
+  const meta = Object.fromEntries((mdx.match(/^---\n([\s\S]*?)\n---/)?.[1] ?? "").split("\n").map((l) => l.split(/:\s(.*)/s).slice(0, 2)).filter((x) => x.length === 2));
+  const ideas = [...mdx.matchAll(/<Idea ([^>]*)>\n([\s\S]*?)\n<\/Idea>/g)].map(([, props, text]) => {
+    const o = { text: unesc(text) };
+    for (const [, k, s, j] of props.matchAll(/(\w+)=(?:("(?:[^"\\]|\\.)*")|\{([^}]*)\})/g)) o[k] = JSON.parse(s ?? j);
+    return o;
+  });
+  return { meta, ideas };
+}
+
+/** Where the ideas cluster, what the phase needs that the dump never mentions, and what it says about products. */
+export function summary(map, phase = "discovery") {
+  const { ideas } = map;
+  const count = (f) => Object.fromEntries(f.map((k) => [k, 0]));
+  const byPillar = count(Object.keys(CONVENTIONS.pillars)), byDept = count(Object.keys(CONVENTIONS.departments)), byRecord = count(Object.keys(CONVENTIONS.records));
+  for (const i of ideas) {
+    if (i.pillar in byPillar) byPillar[i.pillar]++;
+    for (const d of i.departments ?? []) byDept[d]++;
+    for (const r of i.records ?? []) byRecord[r]++;
+  }
+  const n = ideas.length || 1;
+  const strengths = Object.entries(byDept).filter(([, c]) => c).sort((a, b) => b[1] - a[1]).slice(0, 3).map(([d, c]) => ({ department: d, ideas: c, share: Math.round((c / n) * 100) / 100 }));
+  const prior = (d) => { const x = DEPARTMENTS.find((y) => y.id === d); return x?.base?.[phase] ?? 0; };
+  const gaps = Object.entries(byDept).filter(([d, c]) => !c && prior(d) >= 0.4).map(([d]) => ({ department: d, need_now: prior(d), why: DEPARTMENTS.find((y) => y.id === d)?.why ?? null }));
+  const founderRecords = ["validation-problem", "icp", "product", "venture-core"];
+  const unasked = founderRecords.filter((r) => !byRecord[r]).map((r) => ({ record: r, about: CONVENTIONS.records[r].about }));
+  const products = ideas.filter((i) => (i.records ?? []).includes("product"));
+  const existing = ideas.filter((i) => i.exists);
+  return { ideas: ideas.length, by_pillar: byPillar, by_department: byDept, by_record: byRecord, strengths, gaps, unasked,
+    product: { ideas: products.map((i) => i.id), exists: existing.map((i) => ({ id: i.id, text: i.text })), reading: existing.length ? "the dump says something already exists; confirm it in product-exists" : products.length ? "product ideas, none described as existing yet" : "no product ideas in the dump" } };
+}
+
+const ventureOf = (dir) => load(join(dir, "venture.json"));
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const [a, b, c] = process.argv.slice(2);
+  const opt = (n) => { const i = process.argv.indexOf(`--${n}`); return i >= 0 ? process.argv[i + 1] : undefined; };
+  const json = (x) => console.log(JSON.stringify(x, null, 2));
+  if (a === "split") json(split(readFileSync(b, "utf8")));
+  else if (a === "request") json(request(split(readFileSync(join(b, DUMP), "utf8")), ventureOf(b)));
+  else if (a === "answers") json(fromAnswers(load(c).answers ?? load(c)));
+  else if (a === "write") {
+    const ideas = split(readFileSync(join(b, DUMP), "utf8"));
+    mkdirSync(join(b, dirname(MAP)), { recursive: true });
+    writeFileSync(join(b, MAP), render(ideas, load(c), { venture: ventureOf(b).id, tagger: opt("tagger") ?? "unknown" }));
+    console.log(`wrote ${MAP}: ${ideas.length} ideas`);
+  } else if (a && existsSync(join(a, "venture.json"))) {
+    if (!existsSync(join(a, MAP))) { console.error(`${MAP} does not exist yet: the founder submits an idea dump first (node interface/harness/run.mjs discovery --dump <file>)`); process.exit(1); }
+    const s = summary(parse(readFileSync(join(a, MAP), "utf8")), ventureOf(a).phase);
+    if (process.argv.includes("--json")) json({ ...s, ideas_list: parse(readFileSync(join(a, MAP), "utf8")).ideas });
+    else console.log(`${s.ideas} ideas. Pillars: ${Object.entries(s.by_pillar).map(([k, v]) => `${k} ${v}`).join(", ")}.\nStrengths: ${s.strengths.map((x) => `${x.department} (${x.ideas})`).join(", ")}.\nGaps for this phase: ${s.gaps.map((x) => x.department).join(", ") || "none"}.\nNever mentioned: ${s.unasked.map((x) => x.record).join(", ") || "none"}.\nProduct: ${s.product.reading}.`);
+  } else { console.error("usage: node ideamap.mjs <venture> [--json] | split <dump.md> | request <venture> | answers <venture> <answers.json> | write <venture> <tags.json> --tagger <name>"); process.exit(2); }
+}

package/purpose/frameworks/idea-map/route.mjs

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+// Idea routes (EE-061): the step after the idea graph in the pipeline dump -> map -> graph -> routes.
+// The dump's payoff is seeing the ideas on one canvas; the graph's is seeing structure on them. The
+// routes' payoff is next steps: each tagged idea goes to the records it feeds (the framework's
+// destinations, purpose/frameworks/idea-map/conventions.json `records`), and each destination shows
+// where it stands in the framework and the one step that moves it. Nothing here is invented: a
+// destination's stage and next step come from the decision matrix (schema/decisions.mjs), the records
+// on disk and the graph. Read as two Kanban boards:
+//   - destinations, by stage: routed (ideas, nothing drafted yet), drafted (an agent's draft awaits the
+//     founder), yours (a decision only a person can make), waiting (held by another decision), done;
+//   - the decision docket, the same stages for every open decision, each traced to the ideas it comes
+//     from (a decision record's `ideas`, or the i-NN ids its question and answer cite).
+// A destination moves in order (sync) when it sits on the fail-closed path or its ideas share a lane
+// that builds in order; it moves on its own (async) when its decisions fail open or its ideas stand alone.
+// Each destination names its home package (schema/packages.json), and the routes say whether the
+// founder has confirmed the understanding of their ideas yet: routing follows that gate (EE-069).
+//
+//   node route.mjs <venture> [--json]
+
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { decisions } from "../../../schema/decisions.mjs";
+import { CONVENTIONS, MAP, parse } from "./ideamap.mjs";
+import { GRAPH, ORDER } from "./graph.mjs";
+import { confirmedIn } from "../../../schema/foundation.mjs";
+import { loadPackages } from "../../../schema/load-packages.mjs";
+
+const here = dirname(fileURLToPath(import.meta.url));
+const load = (p) => JSON.parse(readFileSync(p, "utf8"));
+const MODEL = load(join(here, "../../../schema/data-model.json")).records;
+
+// Each destination's home package (EE-069, EE-071), so routing shows the packages taking shape.
+const PKG = loadPackages(join(here, "../../.."));
+const HOME = { "venture-core": "foundation", brand: "marketing", ...Object.fromEntries(Object.entries(PKG.core).flatMap(([id, p]) => [...p.required, ...p.optional].map((r) => [r, id]))) };
+
+/** Understand is a gate (EE-069): the founder confirms Mentura read the ideas right, after any
+ *  corrections, before they are routed. A person's confirm of the map after its last agent write. */
+export function understood(dir) {
+  return existsSync(join(dir, MAP)) && confirmedIn(dir, MAP, "ideas");
+}
+
+export const STAGES = [["routed", "Routed"], ["drafted", "Drafted"], ["yours", "Your decision"], ["waiting", "Waiting"], ["done", "Done"]];
+
+/** A decision's Kanban stage: what a person or an agent does next to move it. */
+export function stageOf(d) {
+  if (["done", "withdrawn"].includes(d.render)) return "done";
+  if (["waiting", "later", "deferred"].includes(d.render)) return "waiting";
+  if (d.action?.kind === "write") return "routed";
+  if (d.awaiting || ["accept", "confirm"].includes(d.action?.kind)) return "drafted";
+  return "yours";
+}
+
+/** The ideas a decision comes from: its own `ideas`, then the ids its question and answer cite. */
+export function ideasOf(d) {
+  return [...new Set([...(d.ideas ?? []), ...(`${d.question ?? ""} ${d.answer ?? ""}`.match(/\bi-\d{2,}\b/g) ?? [])])];
+}
+
+// Whether the record a destination writes is on disk (outside _drafts/).
+function written(dir, key) {
+  const m = MODEL.find((r) => r.id === key);
+  const rel = m?.paths?.[0]?.replace(/^instance\/\*\*\//, "");
+  if (!rel) return null;
+  if (rel.includes("*")) { const d = join(dir, dirname(rel)); return existsSync(d) && readdirSync(d).some((f) => f.endsWith(".json")); }
+  return existsSync(join(dir, rel));
+}
+
+export function route(dir, { now } = {}) {
+  const venture = load(join(dir, "venture.json"));
+  const g = existsSync(join(dir, GRAPH)) ? load(join(dir, GRAPH)) : null;
+  const nodes = g?.nodes ?? (existsSync(join(dir, MAP)) ? parse(readFileSync(join(dir, MAP), "utf8")).ideas.map((i) => ({ ...i, signal: null, lane: null })) : []);
+  if (!nodes.length) return { venture: venture.id, phase: venture.phase, waiting: "no idea map yet: map the idea dump first (purpose/ideas)" };
+  const lanes = new Map((g?.lanes ?? []).map((l) => [l.id, l]));
+  const m = decisions(dir, now);
+  const ds = m.decisions.filter((d) => d.source !== "root");
+  const byId = new Map(ds.map((d) => [d.id, d]));
+  const short = (i) => ({ id: i.id, text: i.text, signal: i.signal, lane: i.lane });
+
+  const destinations = [];
+  for (const [key, c] of Object.entries(CONVENTIONS.records)) {
+    const ideas = nodes.filter((n) => n.records?.includes(key)).sort((a, b) => (b.signal ?? 0) - (a.signal ?? 0));
+    const related = ds.filter((d) => c.decisions?.includes(d.id) || (["file", "draft"].includes(d.source) && d.decides?.record === key));
+    const open = related.filter((d) => stageOf(d) !== "done");
+    const ranked = open.filter((d) => d.rank != null).sort((a, b) => b.rank - a.rank);
+    const isWritten = c.route.includes("venture.json") ? related.length > 0 && !open.length : written(dir, key);
+    if (!ideas.length && !related.length) continue;
+    // The step that moves it: the top-ranked decision a person can settle now; else what holds it;
+    // else, with ideas and nothing drafted, an agent's draft from those ideas.
+    const top = ranked.find((d) => stageOf(d) !== "routed") ?? null;
+    const held = !top && open.find((d) => stageOf(d) === "waiting");
+    const ids = ideas.slice(0, 4).map((i) => i.id);
+    let stage, next;
+    if (top) { stage = stageOf(top); next = { by: "founder", decision: top.id, do: top.question, command: top.action?.command }; }
+    else if (held) { const h = byId.get(held.held_by); stage = "waiting"; next = { by: null, decision: held.id, do: h ? `Waits on ${h.id}: ${h.question}` : `Waits until the ${held.needed_in ?? "next"} phase` }; }
+    else if (isWritten && !open.length) { stage = "done"; next = null; }
+    else if (ideas.length) { stage = "routed"; const inVenture = c.route.includes("venture.json");
+      next = { by: "agent", do: `Draft ${(c.title ?? key).toLowerCase()} (${inVenture ? `the ${c.route.split(" ")[1]} statement in venture.json` : c.route}) from ${ids.join(", ")}; the draft waits for the founder to accept`, route: inVenture ? null : c.route }; }
+    else { stage = stageOf(ranked[0] ?? open[0]); next = { by: "founder", decision: (ranked[0] ?? open[0]).id, do: (ranked[0] ?? open[0]).question, command: (ranked[0] ?? open[0]).action?.command }; }
+    const ideaLanes = [...new Set(ideas.map((i) => i.lane).filter(Boolean))].map((l) => lanes.get(l)).filter(Boolean);
+    const failOpen = related.length && related.every((d) => d.boundary === "fail-open");
+    const lane = failOpen || (ideaLanes.length && ideaLanes.every((l) => l.mode === "async")) ? "async" : "sync";
+    destinations.push({ id: key, title: c.title ?? key, route: c.route, stage, lane, order: lane === "sync" ? ORDER.indexOf(key) + 1 : null,
+      signal: ideas.length && ideas[0].signal != null ? ideas[0].signal : null, ideas: ideas.map(short), decisions: related.map((d) => ({ id: d.id, stage: stageOf(d) })), next });
+  }
+  destinations.sort((a, b) => (b.signal ?? -1) - (a.signal ?? -1) || (a.order ?? 99) - (b.order ?? 99));
+
+  // The docket: every decision in a stage, traced to its ideas, or else to its destination's ideas.
+  const destOf = new Map(destinations.flatMap((x) => x.decisions.map((d) => [d.id, x])));
+  const docket = ds.map((d) => {
+    const own = ideasOf(d), dest = destOf.get(d.id);
+    return { id: d.id, question: d.question, stage: stageOf(d), render: d.render, rank: d.rank ?? null, lane: d.lane, boundary: d.boundary, destination: dest?.id ?? null,
+      ideas: own.length ? own : (dest?.ideas ?? []).slice(0, 3).map((i) => i.id), cited: own.length > 0, ...(d.awaiting ? { awaiting: d.awaiting } : {}),
+      ...(d.held_by ? { held_by: d.held_by } : {}), ...(d.action ? { action: d.action } : {}), ...(d.answer ? { answer: d.answer } : {}) };
+  });
+
+  const routed = new Set(destinations.flatMap((x) => x.ideas.map((i) => i.id)));
+  for (const d of destinations) d.package = HOME[d.id] ?? null;
+  return { venture: venture.id, name: venture.name, phase: venture.phase, graph: g?.root ?? null, understood: understood(dir), stages: STAGES, destinations,
+    loose: nodes.filter((n) => !routed.has(n.id)).map(short),
+    gaps: Object.entries(CONVENTIONS.records).filter(([k]) => !destinations.some((x) => x.id === k)).map(([k, c]) => ({ id: k, title: c.title ?? k, about: c.about })),
+    docket, counts: Object.fromEntries(STAGES.map(([s]) => [s, destinations.filter((x) => x.stage === s).length])) };
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const dir = process.argv[2];
+  if (!dir || !existsSync(join(dir, "venture.json"))) { console.error("usage: node route.mjs <venture> [--json]"); process.exit(2); }
+  const r = route(dir);
+  if (process.argv.includes("--json")) console.log(JSON.stringify(r, null, 2));
+  else if (r.waiting) console.log(r.waiting);
+  else {
+    for (const [s, label] of STAGES) {
+      const xs = r.destinations.filter((x) => x.stage === s);
+      if (!xs.length) continue;
+      console.log(`${label}:`);
+      for (const x of xs) console.log(`  ${x.title.padEnd(18)} ${x.lane === "sync" ? `in order #${x.order}` : "on its own"}  ${x.ideas.map((i) => i.id).join(" ")}${x.next ? `\n    next (${x.next.by ?? "nobody yet"}): ${x.next.do}` : ""}`);
+    }
+    if (r.loose.length) console.log(`Loose, on the map only: ${r.loose.map((i) => i.id).join(", ")}`);
+    if (r.gaps.length) console.log(`Nothing in the dump feeds: ${r.gaps.map((x) => x.title).join(", ")}`);
+  }
+}