naive-framework 0.0.0-stage → 0.1.0

package/interface/harness/site.mjs

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+// Site presence, end to end (EE-062): read a venture's website, have Jev judge which pages say what,
+// and score how present the venture's public records are, weighed by who the site must speak to now.
+// The reading and the judging are platform scripts, spawned by path (EE-041); the scoring is Naive's.
+// Without a Jev key the scoring falls back to the matrix's keywords and says so.
+//
+//   node interface/harness/site.mjs <url> [--venture <dir>] [--raising] [--hiring] [--contributors] [--pages 10] [--json]
+
+import { spawn } from "node:child_process";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { factsOf, icpOf, request, score, PRESENCE } from "../../operations/marketing/site/presence.mjs";
+
+const repo = join(dirname(fileURLToPath(import.meta.url)), "../..");
+const run = (script, args, input) => new Promise((resolve) => {
+  const p = spawn("node", [join(repo, script), ...args], { stdio: ["pipe", "pipe", "pipe"] });
+  let out = "", err = "";
+  p.stdout.on("data", (d) => (out += d)); p.stderr.on("data", (d) => (err += d));
+  p.on("close", (code) => resolve({ code, out, err }));
+  p.stdin.end(input ?? "");
+});
+
+/** Read, judge and score one site. Returns the presence result; writes it into the venture if given. */
+export async function scan(url, { venture = null, flags = {}, pages = 10, log = () => {} } = {}) {
+  const t0 = Date.now();
+  const r = await run("platform/integrations/site.mjs", [url, "--pages", String(pages)]);
+  if (r.code !== 0) throw new Error(`could not read ${url}: ${r.err.trim() || `exit ${r.code}`}`);
+  const site = JSON.parse(r.out);
+  log(`read ${site.pages.filter((p) => !p.error).length} pages of ${site.site} via ${site.via} in ${Date.now() - t0} ms`);
+  const icp = icpOf(venture, site);
+  let answers = null;
+  if (process.env.TYPESAFE_API_KEY || process.env.TYPESAFEAI_API_KEY) {
+    const j = await run("platform/integrations/jev.mjs", [], JSON.stringify(request(site, icp)));
+    if (j.code === 0) { const a = JSON.parse(j.out); answers = a.answers; log(`Jev answered ${Object.keys(answers).length} typed questions in ${a.ms} ms`); }
+    else log(`Jev failed (${j.err.trim().slice(0, 200)}); judging by keywords instead`);
+  } else log("no Jev key: judging by keywords, which is rougher");
+  const facts = factsOf(venture, flags);
+  const result = score(site, { answers, facts, icp, venture: venture ? JSON.parse(readFileSync(join(venture, "venture.json"), "utf8")).id : null });
+  if (venture) { mkdirSync(join(venture, dirname(PRESENCE)), { recursive: true }); writeFileSync(join(venture, PRESENCE), JSON.stringify(result, null, 2) + "\n"); }
+  return result;
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const url = process.argv[2];
+  const opt = (n) => { const i = process.argv.indexOf(`--${n}`); return i > 0 ? process.argv[i + 1] : null; };
+  const has = (n) => process.argv.includes(`--${n}`);
+  if (!url || url.startsWith("--")) { console.error("usage: node interface/harness/site.mjs <url> [--venture <dir>] [--raising] [--hiring] [--contributors] [--pages 10] [--json]"); process.exit(2); }
+  const flags = Object.fromEntries(["raising", "hiring", "contributors"].filter(has).map((k) => [k, true]));
+  scan(url, { venture: opt("venture"), flags, pages: Number(opt("pages") ?? 10), log: (m) => console.error(m) }).then((r) => {
+    if (has("json")) return console.log(JSON.stringify(r, null, 2));
+    console.log(`${r.site}: site presence ${r.score}/100 (${r.judged_by})`);
+    console.log(`Customers: ${r.icp.types.map((t) => `${t.label}${t.p != null ? ` ${t.p}` : ""}`).join(", ")}; ICP from ${r.icp.cite}`);
+    for (const n of r.sitemap) console.log(`  ${n.ghost ? "+" : " "} ${n.path.padEnd(28)} ${n.type.padEnd(9)} ${n.rating == null ? (n.read ? "-" : "not read") : n.rating}${n.missing.length ? `  missing: ${n.missing.join(", ")}` : ""}`);
+    console.log(`By audience: ${Object.entries(r.audiences).map(([k, v]) => `${k} ${v.score}${v.weight >= 0.5 ? "" : " (not a priority)"}`).join(", ")}`);
+    for (const x of r.items) console.log(`${x.score === 1 ? "ok  " : x.score ? "low " : "miss"} ${x.label.padEnd(28)} ${x.note}`);
+    console.log(`Fix first: ${r.fix_first.join(", ") || "nothing"}`);
+  }, (e) => { console.error(e.message); process.exit(1); });
+}

package/interface/layer.json

@@ -0,0 +1,31 @@
+{
+  "layer": "interface",
+  "purpose": "Let a person, with agents, work across at least three of the five other layers in one session: agent harnesses (Claude Code, Cursor) and custom interfaces (the operator console), all reaching the system through one route table that a CLI, an MCP server and an HTTP API share (EE-030).",
+  "product": "everything-ecosystem/console",
+  "skills": [
+    {
+      "id": "install-mentura",
+      "path": "interface/skills/install-mentura/SKILL.md"
+    }
+  ],
+  "records": [
+    "route-aliases"
+  ],
+  "reads": [
+    "integration"
+  ],
+  "writes": [],
+  "checks": [
+    "schema/check-integrations.mjs",
+    "interface/test.mjs"
+  ],
+  "gaps": [
+    "The operator console is a folder, not part of the layer yet",
+    "Cannot yet run roles in separate sessions, so one agent can play builder and reviewer",
+    "The CLI cannot tell a person from an agent; the pull request a person merges is the gate that holds",
+    "The HTTP API has no authentication and binds to 127.0.0.1 only",
+    "Views are Markdown; the operator console does not render them yet",
+    "Route groups cover phases only; MAD tiers become groups once record types declare a tier"
+  ],
+  "name": "interface"
+}

package/interface/mcp/server.mjs

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+// The MCP server over the router (EE-030): stdio, newline-delimited JSON-RPC 2.0, no dependencies.
+// Tools are the router's actions; resources are the route table and each venture's records.
+// Every caller here is an agent: write never takes an actor, so a gated record (ownership, board,
+// founder agreement, exit, telos, decision rights, publication policy) is always written as a
+// draft for a person to accept. Nothing an agent sends through this server can approve itself.
+//
+//   claude mcp add mentura -- node <repo>/interface/mcp/server.mjs
+//   MENTURA_WORKSPACE=<dir> sets the workspace; the default is this repository's instance/.
+
+import { createInterface } from "node:readline";
+import { call, routes, routesMd, ventureDir, ventures } from "../router.mjs";
+import { propose } from "../../schema/decisions.mjs";
+
+const PROTOCOL = "2025-06-18";
+const venture = { type: "string", description: "The venture's id, or its folder path for a nested venture (see mentura_ventures)" };
+const route = { type: "string", description: "A route from mentura_routes, such as purpose/validation/problem" };
+export const TOOLS = [
+  { name: "mentura_routes", description: "The route table: every record and command a venture has, with its actions, decision classes and groups. A collection item is <route>/<id>, such as purpose/product/kettle.", inputSchema: { type: "object", properties: { group: { type: "string", description: "Only the routes need-now suggests in this phase: discovery, validation, beachhead, scale or platform" } } } },
+  { name: "mentura_layout", description: "The context for a route before you act on it: the system, layer and kit purpose, skills and references, the schema and template, the gate, and what need-now says about the record.", inputSchema: { type: "object", properties: { venture, route }, required: ["route"] } },
+  { name: "mentura_view", description: "A route as a Markdown page for a person. system/overview shows the venture at a glance.", inputSchema: { type: "object", properties: { venture, route }, required: ["venture", "route"] } },
+  { name: "mentura_ventures", description: "The ventures in the workspace, with their phase.", inputSchema: { type: "object", properties: {} } },
+  { name: "mentura_read", description: "Read one record of a venture. Returns null when the venture has no such record yet.", inputSchema: { type: "object", properties: { venture, route }, required: ["venture", "route"] } },
+  { name: "mentura_write", description: "Write one record of a venture. The record must match its schema. A gated record is written as a draft under _drafts/ for a person to accept. Every write is logged in the venture's provenance log: say what the content came from and the decision it acts under.", inputSchema: { type: "object", properties: { venture, route, record: { type: "object", description: "The whole record" },
+    derived_from: { type: "array", items: { type: "string" }, description: "What the content came from: venture-relative paths, URLs or decision ids" },
+    decision: { type: "string", description: "The decision the write acts under, such as EE-026" },
+    model: { type: "string", description: "Your model, for the provenance log" }, note: { type: "string" },
+    agent_id: { type: "string", description: "Your role in the team plan, so its routes and unlocks apply" } }, required: ["venture", "route", "record"] } },
+  { name: "mentura_decisions", description: "The decisions a venture owes (EE-054): each with its parent, boundary, phase, due time and whether it renders now, is overdue, waits, comes later, is stale or deferred. Work on what renders now or overdue; a decision that waits is held by an open fail-closed decision above it. A route a pending decision unlocks is refused until a person decides it.", inputSchema: { type: "object", properties: { venture,
+    render: { type: "array", items: { type: "string" }, description: "Only these states, such as [\"overdue\", \"now\"]" } }, required: ["venture"] } },
+  { name: "mentura_propose_decision", description: "Propose a decision, or new wording for an open one. It stays open until a person approves it in the CLI (mentura decide); you can never mark a decision decided. Put it beside what it decides with at (a venture folder such as operations) and name (<record>[.<topic>]).", inputSchema: { type: "object", properties: { venture,
+    decision: { type: "object", description: "id, question, and optionally answer (your proposed wording), decides, layer, parent, needed_in, due, outcomes, unlocks, note, plus at and name for where it goes" },
+    agent_id: { type: "string", description: "Your role in the team plan" }, model: { type: "string" } }, required: ["venture", "decision"] } },
+  { name: "mentura_check", description: "Run the checks for one record of a venture.", inputSchema: { type: "object", properties: { venture, route }, required: ["venture", "route"] } },
+  { name: "mentura_template", description: "The fill-in template for a record, where its kit has one.", inputSchema: { type: "object", properties: { route }, required: ["route"] } },
+  { name: "mentura_run", description: "Run a command route for a venture: system/need-now (what to work on now), system/time-to-ready, purpose/validation/assess (what the problem's evidence is strong enough for), governance/payouts, knowledge/catalog (index every source the venture keeps records in), knowledge/search (find items in any of them). A result with needs_input lists what is missing: ask the person whether to fill it in or run as is, and only then call again with as_is.", inputSchema: { type: "object", properties: { venture, route, value: { type: ["number", "string"], description: "governance/payouts: a sale value; knowledge/search: the query" },
+    as_is: { type: "boolean", description: "purpose/validation/assess: run even though the record is incomplete. Set it only after the person chose to run as is" },
+    agent_id: { type: "string", description: "Your role in the team plan" } }, required: ["venture", "route"] } },
+];
+
+let client = null; // the harness, as it named itself at initialize
+
+export async function handle(msg) {
+  const { id, method, params = {} } = msg;
+  const reply = (result) => ({ jsonrpc: "2.0", id, result });
+  const fail = (code, message) => ({ jsonrpc: "2.0", id, error: { code, message } });
+  switch (method) {
+    case "initialize":
+      client = params.clientInfo ? [params.clientInfo.name, params.clientInfo.version].filter(Boolean).join(" ") : null;
+      return reply({ protocolVersion: PROTOCOL, capabilities: { tools: {}, resources: {} }, serverInfo: { name: "mentura", version: "0.1.0" },
+        instructions: "Start with mentura_decisions to see which decisions are due and what is held, then mentura_run on system/need-now to see what a venture needs now, so you build only that. Read before you write. Gated records are drafts until a person accepts them." });
+    case "notifications/initialized": case "notifications/cancelled": return null;
+    case "ping": return reply({});
+    case "tools/list": return reply({ tools: TOOLS });
+    case "tools/call": {
+      const a = params.arguments ?? {};
+      let r;
+      switch (params.name) {
+        case "mentura_routes": r = { ok: true, result: a.group ? routes().filter((x) => x.groups.includes(`(${a.group})`)) : routes() }; break;
+        case "mentura_ventures": r = { ok: true, result: ventures().map(({ id, name, phase, path }) => ({ id, name, phase, path })) }; break;
+        case "mentura_layout": r = await call({ venture: a.venture, route: a.route, action: "layout" }); break;
+        case "mentura_view": r = await call({ venture: a.venture, route: a.route, action: "view" }); break;
+        case "mentura_read": r = await call({ venture: a.venture, route: a.route, action: "read" }); break;
+        case "mentura_write": r = await call({ venture: a.venture, route: a.route, action: "write", input: a.record, actor: "agent", actor_id: a.agent_id, via: "mcp",
+          provenance: { derived_from: a.derived_from, decision: a.decision, note: a.note, agent: Object.fromEntries(Object.entries({ harness: client, model: a.model }).filter(([, v]) => v)) } }); break;
+        case "mentura_decisions": {
+          r = await call({ venture: a.venture, route: "governance/decisions", action: "run", actor_id: a.agent_id });
+          if (r.ok && a.render?.length) r.result = { ...r.result, decisions: r.result.decisions.filter((d) => a.render.includes(d.render)) };
+          break;
+        }
+        case "mentura_propose_decision": {
+          const dir = ventureDir(a.venture);
+          r = dir ? propose(dir, a.decision, { agentId: a.agent_id, via: "mcp", harness: client, model: a.model }) : { ok: false, error: `no venture ${a.venture}` };
+          break;
+        }
+        case "mentura_check": r = await call({ venture: a.venture, route: a.route, action: "check" }); break;
+        case "mentura_template": r = await call({ route: a.route, action: "template" }); break;
+        case "mentura_run": r = await call({ venture: a.venture, route: a.route, action: "run", actor_id: a.agent_id, input: a.value !== undefined || a.as_is ? { ...(a.value !== undefined ? { value: a.value } : {}), ...(a.as_is ? { as_is: true } : {}) } : undefined }); break;
+        default: return fail(-32602, `unknown tool ${params.name}`);
+      }
+      if (r.ok && r.needs_input) return reply({ content: [{ type: "text", text: `Ask the person before running. ${r.needs_input.ask}\n${JSON.stringify(r.needs_input, null, 2)}` }], isError: false });
+      const extra = ["not_found", "pending_draft", "fix", "deprecated"].some((k) => r[k]);
+      const text = r.ok ? (typeof r.result === "string" && !extra ? r.result : JSON.stringify(extra ? r : r.result, null, 2)) : JSON.stringify({ error: r.error, ...(r.fix ? { fix: r.fix } : {}), ...(r.result ? { result: r.result } : {}) }, null, 2);
+      return reply({ content: [{ type: "text", text }], isError: !r.ok });
+    }
+    case "resources/list":
+      return reply({ resources: [
+        { uri: "mentura://routes", name: "Route table", mimeType: "text/markdown" },
+        ...ventures().map((v) => ({ uri: `mentura://${v.id}`, name: `${v.id}: overview`, mimeType: "text/markdown" })),
+        ...ventures().flatMap((v) => routes().filter((x) => x.kind === "record" && !x.route.endsWith("[id]")).map((x) => ({ uri: `mentura://${v.id}/${x.route}`, name: `${v.id}: ${x.route}`, mimeType: "application/json" }))),
+      ] });
+    case "resources/read": {
+      const uri = params.uri ?? "";
+      if (uri === "mentura://routes") return reply({ contents: [{ uri, mimeType: "text/markdown", text: routesMd() }] });
+      const o = uri.match(/^mentura:\/\/([^/]+)$/);
+      if (o) { const r = await call({ venture: o[1], route: "system/overview", action: "view" }); return r.ok ? reply({ contents: [{ uri, mimeType: "text/markdown", text: r.result }] }) : fail(-32602, r.error); }
+      const m = uri.match(/^mentura:\/\/([^/]+)\/(.+)$/);
+      if (!m) return fail(-32602, `unknown resource ${uri}`);
+      const r = await call({ venture: m[1], route: m[2], action: "read" });
+      if (!r.ok) return fail(-32602, r.error);
+      return reply({ contents: [{ uri, mimeType: "application/json", text: JSON.stringify(r.result, null, 2) }] });
+    }
+    default:
+      return id === undefined ? null : fail(-32601, `method not found: ${method}`);
+  }
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const rl = createInterface({ input: process.stdin });
+  // Answers go out in the order requests came in: each line waits for the one before.
+  let queue = Promise.resolve();
+  rl.on("line", (line) => {
+    if (!line.trim()) return;
+    queue = queue.then(async () => {
+      let msg;
+      try { msg = JSON.parse(line); } catch { process.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: null, error: { code: -32700, message: "parse error" } }) + "\n"); return; }
+      let res;
+      try { res = await handle(msg); } catch (e) { res = { jsonrpc: "2.0", id: msg.id ?? null, error: { code: -32603, message: String(e.message ?? e) } }; }
+      if (res) process.stdout.write(JSON.stringify(res) + "\n");
+    });
+  });
+}

package/interface/operator-console/README.md

@@ -0,0 +1,58 @@
+---
+type: entity-readme
+ai-model: claude
+entity-name: operator-console
+companion-to: "[[project-view-mockup-2026-05-14.html]]"
+source: hybrid
+created: 2026-05-14
+last-reviewed: 2026-05-14
+authorship: hybrid
+authors: [the author, Claude]
+ip-sensitivity: normal
+scope: global
+scope-entity: "[[everything-ecosystem]]"
+tags: [operator-console, methodology-product, orchestration-software, mockup, html-companion, 2026-05-14]
+---
+
+# `operator-console/` — The Operator Console
+
+*Renamed from `harness/` on 2026-10-26 (G-029): "harness" now means only the entity class for a first-party interface over a product.*
+
+> Working folder for the operator console — the operational software layered on top of the SAD methodology. Per §39, the trajectory is HTML now → real software later. The first mockup is **[[project-view-mockup-2026-05-14.html]]**. Open it in a browser.
+
+## What this is
+
+The operator console is the methodology's operational consumer surface. It's the dashboard a solo operator (or eventually a multi-person team) lives in when managing projects under the methodology. Distinct from:
+
+- **The methodology itself** ([[pipeline-canonical-view-2026-05-14]]) — the abstract framework
+- **The methodology website** (separate concern; for publishing + teaching + onboarding to the public)
+- **Per-entity orchestration HTML** ([[per-entity-orchestration-template]]) — the static, vault-embedded version of similar information
+
+The operator console is a polished SaaS-style application that surfaces project state, agent activity, and methodology mechanisms (skills, commands, hooks) for the operator.
+
+## Current state
+
+- **[[project-view-mockup-2026-05-14.html]]** — high-fidelity static mockup of the project-level view (the reference project as the demonstrative project)
+- Topbar with project switcher; left sidebar with project + operations + methodology nav groups; main area showing three-pillar prominence + agent system panel + recent decisions + quick action cards
+
+## Trajectory
+
+Per §39 orchestration trajectory:
+
+- **Now:** static HTML mockup for design iteration
+- **Next:** real web app (Next.js + Postgres likely), bespoke for the owner's solo use initially
+- **Later:** multi-person team support (auth, real-time collaboration, role-based access)
+- **Eventually:** publicly available methodology product (when the methodology generalizes beyond the reference project)
+
+Paused as of 2026-05-14 to return to the reference project work. Will resume after V1.5 articulation has more shape.
+
+## Related
+
+- [[pipeline-canonical-view-2026-05-14]] — the methodology the operator console operationalizes
+- [[per-entity-orchestration-template]] — vault-embedded parallel artifact (less polished, more comprehensive)
+- A project note — the orchestration HTML instance the operator console mockup demonstrates against
+- [[build-roadmap-and-html-orchestration-2026-05-12]] §32 + §39 — methodology amendments establishing the operator console concept
+
+## Status
+
+- **2026-05-14:** Initial mockup authored; paused to return to the reference project V1.5 work.

package/interface/provenance.mjs

@@ -0,0 +1,42 @@
+// The provenance log (EE-031): one append-only JSON line per write, after W3C PROV (entity,
+// activity, agent, derived from). Each line carries the previous line's hash, so an edited or
+// deleted line breaks the chain. Lives at <venture>/provenance.jsonl, in the system layer, so it
+// is on whatever layers a venture uses. Git history stays the implicit provenance for anything
+// written outside the router.
+
+import { createHash } from "node:crypto";
+import { appendFileSync, existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+export const LOG = "provenance.jsonl";
+const sha = (s) => createHash("sha256").update(s).digest("hex");
+const sorted = (x) => Array.isArray(x) ? x.map(sorted) : x && typeof x === "object" ? Object.fromEntries(Object.keys(x).sort().map((k) => [k, sorted(x[k])])) : x;
+export const lineHash = (prev, entry) => { const { hash, ...rest } = entry; return sha(prev + JSON.stringify(sorted(rest))); };
+export const contentHash = (file) => sha(readFileSync(file));
+
+export function entries(dir) {
+  const f = join(dir, LOG);
+  return existsSync(f) ? readFileSync(f, "utf8").split("\n").filter((l) => l.trim()).map((l) => JSON.parse(l)) : [];
+}
+
+/** The agent behind this process: MENTURA_ACTOR (person or agent), MENTURA_ACTOR_ID, MENTURA_MODEL, MENTURA_SESSION, MENTURA_HARNESS. */
+export function agentFromEnv(kind, via, extra = {}) {
+  const e = process.env;
+  const a = { kind, via, id: e.MENTURA_ACTOR_ID, model: kind === "agent" ? e.MENTURA_MODEL : undefined, session: e.MENTURA_SESSION, harness: e.MENTURA_HARNESS, ...extra };
+  return Object.fromEntries(Object.entries(a).filter(([, v]) => v));
+}
+
+/**
+ * Appends one entry for a file just written: a path relative to the venture folder, or, for a
+ * record in another source (EE-037), its address (<source>://<path>) with the content's sha256
+ * and the source's version, commit and pull request.
+ */
+export function record(dir, { entity, route, activity, agent, derived_from, decision, note, sha256, source, statement }) {
+  const prior = entries(dir);
+  const prev = prior.length ? prior.at(-1).hash : "genesis";
+  const entry = Object.fromEntries(Object.entries({ at: new Date().toISOString(), entity, route, activity, agent,
+    derived_from: derived_from?.length ? derived_from : undefined, decision, note, source, statement, sha256: sha256 ?? contentHash(join(dir, entity)), prev }).filter(([, v]) => v !== undefined));
+  entry.hash = lineHash(prev, entry);
+  appendFileSync(join(dir, LOG), JSON.stringify(entry) + "\n");
+  return entry;
+}

package/interface/references/references.json

@@ -0,0 +1,28 @@
+{
+  "layer": "interface",
+  "references": [
+    {
+      "id": "anthropic-2024-building-effective-agents",
+      "title": "Building effective agents",
+      "authors": [
+        "Erik Schluntz",
+        "Barry Zhang"
+      ],
+      "year": 2024,
+      "kind": "article",
+      "summary": "Agentic systems split into workflows, where LLMs and tools are orchestrated through predefined code paths, and agents, where LLMs dynamically direct their own processes and tool usage, keeping control over how they accomplish a task.",
+      "url": "https://www.anthropic.com/engineering/building-effective-agents",
+      "checked": "2026-10-27",
+      "informs": [
+        "noun:agent-harness",
+        "noun:ai-harness",
+        "noun:ai-feature",
+        "field:product.ai"
+      ],
+      "stance": {
+        "is": "adopted",
+        "why": "Its line between a workflow and an agent is the line between an AI harness and an agent harness: in an agent harness the model directs its own steps and tool use."
+      }
+    }
+  ]
+}

package/interface/route-aliases.json

@@ -0,0 +1,32 @@
+{
+  "aliases": [
+    {
+      "from": "execution/handoff",
+      "to": "operations/handoff",
+      "since": "2026-10-28",
+      "note": "Execution folded into operations (EE-038)"
+    },
+    { "from": "purpose/validation/problem", "to": "foundation/problem", "since": "2026-10-29", "note": "Package folder layout (EE-070)" },
+    { "from": "purpose/icp", "to": "foundation/icp", "since": "2026-10-29", "note": "Package folder layout (EE-070)" },
+    { "from": "purpose/telos", "to": "foundation/telos", "since": "2026-10-29", "note": "Package folder layout (EE-070)" },
+    { "from": "purpose/alignment", "to": "foundation/alignment", "since": "2026-10-29", "note": "Package folder layout (EE-070)" },
+    { "from": "purpose/validation/solution", "to": "validation/solution", "since": "2026-10-29", "note": "Package folder layout (EE-070)" },
+    { "from": "purpose/validation/pricing", "to": "validation/pricing", "since": "2026-10-29", "note": "Package folder layout (EE-070)" },
+    { "from": "purpose/validation/go-to-market", "to": "validation/go-to-market", "since": "2026-10-29", "note": "Package folder layout (EE-070)" },
+    { "from": "purpose/validation/product-market-fit", "to": "validation/product-market-fit", "since": "2026-10-29", "note": "Package folder layout (EE-070)" },
+    { "from": "purpose/validation/operations-readiness", "to": "validation/operations-readiness", "since": "2026-10-29", "note": "Package folder layout (EE-070)" },
+    { "from": "purpose/validation/team", "to": "people/team", "since": "2026-10-29", "note": "Package folder layout (EE-070)" },
+    { "from": "operations/team-plan", "to": "people/team-plan", "since": "2026-10-29", "note": "Package folder layout (EE-070)" },
+    { "from": "operations/marketing-sitemap", "to": "marketing/sitemap", "since": "2026-10-29", "note": "Package folder layout (EE-070)" },
+    { "from": "operations/marketing-content", "to": "marketing/content", "since": "2026-10-29", "note": "Package folder layout (EE-070)" },
+    { "from": "purpose/idea-dump", "to": "raw/dump", "since": "2026-10-29", "note": "Package folder layout (EE-070)" },
+    { "from": "purpose/idea-map", "to": "ideas/map", "since": "2026-10-29", "note": "Package folder layout (EE-070)" },
+    { "from": "purpose/idea-graph", "to": "ideas/graph", "since": "2026-10-29", "note": "Package folder layout (EE-070)" },
+    { "from": "purpose/product", "to": "product", "since": "2026-10-29", "note": "Package folder layout (EE-070)" },
+    { "from": "evidence/evidence", "to": "evidence", "since": "2026-10-29", "note": "Package folder layout (EE-070)" },
+    { "from": "purpose/anatomy-answers", "to": "product/anatomy-answers", "since": "2026-10-29", "note": "Package folder layout (EE-070)" },
+    { "from": "purpose/anatomy-input", "to": "product/anatomy", "since": "2026-10-29", "note": "Package folder layout (EE-070)" },
+    { "from": "system/venture-package", "to": ".release/venture-package", "since": "2026-10-29", "note": "The deliverable is a release (EE-071)" },
+    { "from": "governance/decision-record", "to": "decisions", "since": "2026-10-29", "note": "Package folder layout (EE-070)" }
+  ]
+}