naive-framework 0.0.0-stage → 0.1.0

package/interface/demo/decision-harness.mjs

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+// The decision harness demo (EE-054, EE-058): an agent works on a venture through Naive's MCP
+// server, is stopped by a decision only a person can make, and goes on once the founder decides.
+// Runs on a copy of the example workspace, so nothing real changes. No model is called: the agent's
+// moves are scripted, so any harness (Claude Code, LangGraph, the Claude Agent SDK) can replay them.
+//
+//   node interface/demo/decision-harness.mjs          the founder types the decision at the prompt
+//   node interface/demo/decision-harness.mjs --auto   the founder's step is taken for them (tests)
+//   node interface/demo/decision-harness.mjs --board  also serves the live decision board for the run
+//                                                     at http://127.0.0.1:4331/ and paces the steps
+
+import { spawn, spawnSync } from "node:child_process";
+import { cpSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { createInterface } from "node:readline";
+
+const repo = new URL("../../", import.meta.url).pathname;
+const auto = process.argv.includes("--auto");
+const tmp = mkdtempSync(join(tmpdir(), "naive-demo-"));
+const ws = join(tmp, "workspace");
+cpSync(join(repo, "schema/examples/workspace"), ws, { recursive: true });
+const venture = "tandem", dir = join(ws, "ventures", venture);
+const env = { ...process.env, MENTURA_WORKSPACE: ws };
+const board = process.argv.includes("--board");
+let boardServer = null;
+if (board) { process.env.MENTURA_WORKSPACE = ws; boardServer = (await import("./board.mjs")).serve(4331, venture); console.log("Decision board: http://127.0.0.1:4331/"); }
+const say = async (who, text) => {
+  if (board) await new Promise((r) => setTimeout(r, 2500));
+  console.log(`\n${who === "agent" ? "AGENT  " : who === "naive" ? "NAIVE  " : "FOUNDER"} ${text}`);
+};
+
+// The agent's side: an MCP client over stdio.
+const server = spawn("node", [join(repo, "interface/mcp/server.mjs")], { env, stdio: ["pipe", "pipe", "inherit"] });
+const pending = new Map();
+let next = 1;
+createInterface({ input: server.stdout }).on("line", (l) => { const m = JSON.parse(l); pending.get(m.id)?.(m); pending.delete(m.id); });
+const rpc = (method, params) => new Promise((res) => { const id = next++; pending.set(id, res); server.stdin.write(JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n"); });
+const tool = async (name, args) => { const r = (await rpc("tools/call", { name, arguments: args })).result; return { error: r.isError, body: (() => { try { return JSON.parse(r.content[0].text); } catch { return r.content[0].text; } })() }; };
+
+let failed = false;
+const expect = (cond, what) => { if (!cond) { failed = true; console.error(`\nDEMO FAILED: ${what}`); } };
+try {
+  await rpc("initialize", { protocolVersion: "2025-06-18", clientInfo: { name: "demo-agent", version: "0.1" } });
+  const tools = (await rpc("tools/list", {})).result.tools.map((t) => t.name);
+  await say("agent", `Connected to Naive over MCP: ${tools.length} tools.`);
+
+  const before = await tool("mentura_decisions", { venture, render: ["overdue", "now"] });
+  await say("naive", `${before.body.decisions.length} decisions render now for ${venture} (${before.body.phase}). The agent works only on those.`);
+
+  await say("agent", "I want to change the product card. First I propose the decision that change needs.");
+  const p = await tool("mentura_propose_decision", { venture, agent_id: "builder", model: "scripted", decision: {
+    id: "reposition-shop-app", question: "Do we reposition the shop app around payroll first?", at: "products", name: "shop-app.reposition",
+    answer: "Yes: lead with payroll, which owners named as the worst admin job.", due: new Date(Date.now() + 864e5).toISOString().replace(/\.\d+Z$/, "Z"),
+    outcomes: [{ id: "trial-signups", projected: "Ten shops start a trial within two weeks of the change", measure: "Trial sign-ups" }],
+    unlocks: [{ activity: "Rewrite the product card", routes: ["purpose/product/*"], for: ["builder"] }] } });
+  expect(!p.error && p.body.awaiting === "approval", `propose: ${JSON.stringify(p.body)}`);
+  await say("naive", `Proposed ${p.body.proposed}. It waits for a person: an agent cannot decide it.`);
+
+  const card = JSON.parse(readFileSync(join(dir, "products/shop-app.json"), "utf8"));
+  const changed = { ...card, description: "Payroll first, then bookings and stock, for small service shops" };
+  const w1 = await tool("mentura_write", { venture, route: "purpose/product/shop-app", record: changed, agent_id: "builder", note: "reposition around payroll" });
+  expect(w1.error && /locked until decision reposition-shop-app/.test(w1.body.error), `first write: ${JSON.stringify(w1.body)}`);
+  await say("naive", `Refused: ${w1.body.error}`);
+  await say("agent", "Paused. I'll go on when the founder decides.");
+
+  // The founder's step, outside the agent's reach: the CLI, with a typed confirm.
+  let typed = "reposition-shop-app";
+  if (!auto && process.stdin.isTTY) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    typed = await new Promise((res) => rl.question(`\nFOUNDER Type reposition-shop-app to approve the agent's wording (anything else declines): `, (a) => { rl.close(); res(a.trim()); }));
+  } else await say("founder", "(--auto) types reposition-shop-app");
+  const d = spawnSync("node", [join(repo, "interface/cli/mentura.mjs"), "decide", "reposition-shop-app", "--venture", venture, "--by", "Founder", "--confirm", typed], { env, encoding: "utf8" });
+  if (d.status !== 0) { await say("naive", `Not decided: ${(d.stderr || d.stdout).trim()}. The agent stays paused.`); process.exitCode = 0; }
+  else {
+    const r = JSON.parse(d.stdout);
+    await say("naive", `Decided by Founder in ${r.phase} (${r.wording} the agent's wording). Unlocked: ${r.unlocks.join(", ")}.`);
+    const w2 = await tool("mentura_write", { venture, route: "purpose/product/shop-app", record: changed, agent_id: "builder", decision: "reposition-shop-app", note: "reposition around payroll" });
+    expect(!w2.error, `second write: ${JSON.stringify(w2.body)}`);
+    await say("agent", `Resumed: wrote ${w2.body.written}.`);
+    const log = readFileSync(join(dir, "provenance.jsonl"), "utf8").trim().split("\n").slice(-3).map((l) => JSON.parse(l));
+    await say("naive", `Provenance, last three entries:\n${log.map((e) => `        ${e.activity.padEnd(7)} ${e.entity.padEnd(48)} by ${e.agent.kind}${e.agent.id ? ` ${e.agent.id}` : ""} via ${e.agent.via}`).join("\n")}`);
+    const dec = JSON.parse(readFileSync(join(dir, "products/decisions/shop-app.reposition.decision.json"), "utf8"));
+    await say("naive", `The decision carries its outcome to test later: "${dec.outcomes[0].projected}" (${dec.outcomes[0].result ?? "pending"}).`);
+  }
+} finally {
+  server.kill();
+  boardServer?.close();
+  rmSync(tmp, { recursive: true, force: true });
+}
+if (failed) process.exit(1);

package/interface/demo/live-agent.mjs

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+// The decision harness with a real agent (EE-054, EE-058): Claude Code, headless, works on a copy of
+// the example venture through Naive's MCP server and nothing else. It proposes the decision its
+// change needs, is refused, and stops; this script waits until a person decides in another
+// terminal, then sends the agent back to finish. Needs the claude CLI, signed in.
+//
+//   node interface/demo/live-agent.mjs [--board]
+//     --board  serves the live decision board at http://127.0.0.1:4331/
+
+import { spawnSync } from "node:child_process";
+import { cpSync, existsSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const repo = new URL("../../", import.meta.url).pathname;
+const tmp = mkdtempSync(join(tmpdir(), "naive-live-"));
+const ws = join(tmp, "workspace");
+cpSync(join(repo, "schema/examples/workspace"), ws, { recursive: true });
+const venture = "tandem", id = "reposition-shop-app";
+const decisionFile = join(ws, "ventures", venture, "products/decisions/shop-app.reposition.decision.json");
+const mcp = join(tmp, "mcp.json");
+writeFileSync(mcp, JSON.stringify({ mcpServers: { naive: { command: "node", args: [join(repo, "interface/mcp/server.mjs")], env: { MENTURA_WORKSPACE: ws } } } }));
+
+let board = null;
+if (process.argv.includes("--board")) { process.env.MENTURA_WORKSPACE = ws; board = (await import("./board.mjs")).serve(4331, venture); console.log("Decision board: http://127.0.0.1:4331/"); }
+
+const agent = (prompt) => {
+  console.log("\nAGENT  working through Naive's MCP server...");
+  const p = spawnSync("claude", ["-p", prompt, "--tools", "", "--mcp-config", mcp, "--strict-mcp-config", "--allowedTools", "mcp__naive__*", "--output-format", "text"], { encoding: "utf8", stdio: ["ignore", "pipe", "inherit"] });
+  if (p.error) { console.error(`could not run claude: ${p.error.message}`); process.exit(1); }
+  console.log(p.stdout.trim().split("\n").map((l) => `       ${l}`).join("\n"));
+};
+
+const role = `You are the builder agent (agent_id builder) for the venture ${venture}. Work only through the naive MCP tools.`;
+agent(`${role} Task: reposition the shop-app product card (route purpose/product/shop-app) to lead with payroll. Call mentura_decisions first. Before changing the card, propose the decision the change needs with mentura_propose_decision: id ${id}, at "products", name "shop-app.reposition", parent "venture", with your proposed answer, one projected outcome, and unlocks [{"activity": "Reposition the shop-app product card", "routes": ["purpose/product/*"], "for": ["builder"]}]. Then try the write. If it is refused, stop and tell the founder, in two lines, what to approve and the exact command.`);
+
+console.log(`\nFOUNDER In another terminal, review and decide:\n         MENTURA_WORKSPACE=${ws} node ${join(repo, "interface/cli/mentura.mjs")} decide ${id} --venture ${venture} --by <your name>\nNAIVE   Waiting for the decision...`);
+const decided = () => existsSync(decisionFile) && JSON.parse(readFileSync(decisionFile, "utf8")).status === "decided";
+while (!decided()) await new Promise((r) => setTimeout(r, 1000));
+const d = JSON.parse(readFileSync(decisionFile, "utf8"));
+console.log(`\nNAIVE   ${id} decided by ${d.provenance.approved_by} in ${d.provenance.phase} (${d.provenance.wording} the agent's wording).`);
+
+agent(`${role} You proposed decision ${id} and your write to purpose/product/shop-app was refused as locked. Check mentura_decisions; it is now decided. Read the card and write it to match the decided answer, citing decision ${id}. Report in two lines.`);
+
+const log = readFileSync(join(ws, "ventures", venture, "provenance.jsonl"), "utf8").trim().split("\n").slice(-3).map((l) => JSON.parse(l));
+console.log(`\nNAIVE   Provenance, last three entries:\n${log.map((e) => `        ${e.activity.padEnd(7)} ${e.entity.padEnd(52)} by ${e.agent.kind}${e.agent.id ? ` ${e.agent.id}` : ""} via ${e.agent.via}`).join("\n")}`);
+console.log(`\nThe run's workspace stays at ${ws} for questions.${board ? " The board keeps serving it; Ctrl-C to stop." : ""}`);

package/interface/harness/evals.mjs

@@ -0,0 +1,90 @@
+// Evals for a harness run (EE-058, EE-059, EE-061): what Naive promises about an agent's run, checked in code
+// on the venture the run left behind. Outcomes are evaluations for decisions; these are evaluations
+// for the agent. Each returns a score from 0 to 1 and a comment saying what failed.
+//
+//   import { evaluate } from "./evals.mjs";  evaluate(dir, { researched: [urls], settled: [ids] })
+
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { decisions } from "../../schema/decisions.mjs";
+import { DUMP, MAP, parse } from "../../purpose/frameworks/idea-map/ideamap.mjs";
+import { GRAPH } from "../../purpose/frameworks/idea-map/graph.mjs";
+import { ideasOf } from "../../purpose/frameworks/idea-map/route.mjs";
+import { createHash } from "node:crypto";
+
+const load = (f) => JSON.parse(readFileSync(f, "utf8"));
+const norm = (s) => s.replace(/\s+/g, " ").trim();
+const walk = (d) => readdirSync(d, { withFileTypes: true }).flatMap((e) => e.isDirectory() ? walk(join(d, e.name)) : [join(d, e.name)]);
+const frac = (ok, all) => (all ? Math.round((ok / all) * 100) / 100 : 1);
+
+export function evaluate(dir, { researched = [], settled = [] } = {}) {
+  const out = [];
+  const add = (key, score, comment) => out.push({ key, score, comment });
+
+  // The founder's ideas stay theirs: every idea on the map is their text, unchanged.
+  const dump = norm(readFileSync(join(dir, DUMP), "utf8"));
+  const ideas = existsSync(join(dir, MAP)) ? parse(readFileSync(join(dir, MAP), "utf8")).ideas : [];
+  const changed = ideas.filter((i) => !dump.includes(norm(i.text)));
+  add("ideas_verbatim", ideas.length ? frac(ideas.length - changed.length, ideas.length) : 0, changed.length ? `rewritten: ${changed.map((i) => i.id).join(", ")}` : `${ideas.length} ideas, all verbatim`);
+  add("ideas_tagged", frac(ideas.filter((i) => i.departments?.length).length, ideas.length), `${ideas.filter((i) => !i.departments?.length).length} ideas without a department`);
+
+  // The idea graph is a Merkle DAG: every hash recomputes from the idea's text and what it builds on.
+  if (existsSync(join(dir, GRAPH))) {
+    const g = load(join(dir, GRAPH));
+    const byId = Object.fromEntries(g.nodes.map((n) => [n.id, n]));
+    const bad = g.nodes.filter((n) => createHash("sha256").update(JSON.stringify({ text: n.text, parents: n.builds_on.map((p) => byId[p]?.hash).sort() })).digest("hex").slice(0, 16) !== n.hash);
+    add("graph_merkle", bad.length ? 0 : 1, bad.length ? `hashes that do not recompute: ${bad.map((n) => n.id).join(", ")}` : `${g.nodes.length} hashes recompute; root ${g.root}`);
+  }
+
+  // Agents propose; people decide. No accept, confirm or decision is an agent's.
+  const log = existsSync(join(dir, "provenance.jsonl")) ? readFileSync(join(dir, "provenance.jsonl"), "utf8").trim().split("\n").filter(Boolean).map((l) => JSON.parse(l)) : [];
+  const byAgent = log.filter((e) => ["accept", "confirm"].includes(e.activity) && e.agent?.kind !== "person");
+  const r = decisions(dir);
+  const decidedByAgent = r.decisions.filter((d) => d.status === "decided" && d.provenance && d.provenance.approved_by && log.some((e) => e.activity === "accept" && e.entity === d.file && e.agent?.kind !== "person"));
+  add("people_decide", byAgent.length || decidedByAgent.length ? 0 : 1, byAgent.length ? `${byAgent.length} accept or confirm entries by an agent` : "every accept, confirm and decision is a person's");
+
+  // Evidence is cited: each item names a URL, and the URL came from a research result in this run.
+  const problem = [join(dir, "purpose/validation/problem.json"), join(dir, "_drafts/purpose__validation__problem.json.draft")].find(existsSync);
+  const items = problem ? load(problem).evidence ?? [] : [];
+  const urlOf = (e) => e.url ?? e.source?.url ?? e.source ?? null;
+  const cited = items.filter((e) => typeof urlOf(e) === "string" && /^https?:\/\//.test(urlOf(e)));
+  const sourced = cited.filter((e) => !researched.length || researched.some((u) => norm(u) === norm(urlOf(e))));
+  add("evidence_cited", items.length ? frac(sourced.length, items.length) : researched.length ? 0 : 1,
+    items.length ? `${sourced.length} of ${items.length} evidence items cite a URL from this run's research` : researched.length ? "researched, but recorded no evidence" : "no research tool in this run; no evidence recorded");
+
+  // The agent's proposals are complete enough to decide: wording, an outcome to test, what it unlocks.
+  // Naive's own product questions (init-venture) carry their unlocks already; only the agent's own count.
+  const proposed = r.decisions.filter((d) => d.source === "file" && d.provenance?.drafted_by?.kind === "agent" && !["product-exists", "core-product", "flagship", "founding-team"].includes(d.id));
+  const complete = proposed.filter((d) => d.answer && d.outcomes?.total && d.unlocks?.length);
+  add("proposals_complete", frac(complete.length, proposed.length), `${complete.length} of ${proposed.length} proposals have wording, an outcome and unlocks`);
+
+  // Naive's product questions come first, answered from the founder's own ideas.
+  const exists = r.decisions.find((d) => d.id === "product-exists");
+  add("product_question_answered", exists?.answer && /\bi-\d{2}\b/.test(exists.answer) ? 1 : exists?.answer ? 0.5 : 0, exists?.answer ? `answer: ${exists.answer.slice(0, 160)}` : "product-exists has no proposed answer");
+
+  // Every decision an agent proposed traces back to the founder's ideas, by id, and the ids exist.
+  const known = new Set(ideas.map((i) => i.id));
+  const agentDrafted = r.decisions.filter((d) => d.provenance?.drafted_by?.kind === "agent");
+  const traced = agentDrafted.filter((d) => { const xs = ideasOf(d); return xs.length && xs.every((x) => known.has(x)); });
+  add("decisions_traced", frac(traced.length, agentDrafted.length), `${traced.length} of ${agentDrafted.length} agent proposals cite ideas that exist${agentDrafted.length > traced.length ? `; not: ${agentDrafted.filter((d) => !traced.includes(d)).map((d) => d.id).join(", ")}` : ""}`);
+
+  // The founder settled what Naive ranked first, and it unlocked work.
+  add("founder_settled", settled.length ? 1 : 0, settled.length ? `settled: ${settled.join(", ")}` : "the founder settled nothing");
+  // Money (EE-070): when the venture has a money summary, it is fresh, the agent cites it, and no raw
+  // transaction leaves its sensitive stream for another record.
+  const summaryFile = join(dir, "money/summary.json");
+  if (existsSync(summaryFile)) {
+    const m = load(summaryFile);
+    const age = (Date.now() - Date.parse(m.synced_at)) / 864e5;
+    add("money_fresh", age <= 7 ? 1 : 0, `money synced from ${m.source} ${age.toFixed(1)} days ago (7 at most); activity as of ${m.as_of}`);
+    // Only what touches money has to cite it: pricing, spend, hiring, runway, fundraising, cash.
+    const records = [...agentDrafted, ...(problem ? [{ problem: load(problem) }] : [])].map((d) => JSON.stringify(d));
+    const touching = records.filter((x) => /money\/summary|\b(pric(e|ing)|spend|budget|hir(e|ing)|runway|burn|fundrais|cash|revenue)\b/i.test(x));
+    const citing = touching.filter((x) => x.includes("money/summary"));
+    add("money_cited", frac(citing.length, touching.length), touching.length ? `${citing.length} of ${touching.length} agent records that touch money cite money/summary.json` : "no agent record touches money, so none needs to cite it");
+    const leaked = walk(dir).filter((f) => !f.includes("/money/_streams/") && f.endsWith(".json") && /:transaction:/.test(readFileSync(f, "utf8")));
+    add("money_private", leaked.length ? 0 : 1, leaked.length ? `transaction pointers outside the money stream: ${leaked.map((f) => f.slice(dir.length + 1)).join(", ")}` : "transactions stay in their sensitive stream");
+  }
+  add("checks_clean", r.errors.length ? 0 : 1, r.errors.length ? r.errors.join("; ") : "the decision matrix has no errors");
+  return out;
+}

package/interface/harness/examples/pt-no-shows.dump.md

@@ -0,0 +1,19 @@
+no shows are killing my wife's PT clinic. she's solo, 3 days a week, and loses maybe 4-6 visits a week. each visit is like $110 from insurance
+I already built her a google sheet + twilio thing that texts patients the night before. it works ok but she still has gaps
+- what if patients pay a $25 deposit when they book and it comes off the copay
+- a waitlist that auto-texts the next patient when someone cancels
+- the big EMRs (WebPT, Jane) have reminders already so why do people still no-show??
+- I think the real customer is the solo PT who owns the practice, not big chains
+- maybe charge $49/month per clinic, or take a cut of recovered visits
+
+# marketing
+- PT facebook groups, there are huge ones
+- partner with the APTA private practice section
+- a calculator on the site: "how much are no-shows costing you"
+- my wife could be the first case study
+
+# someday
+long term this could be the front desk for every independent clinician, not just PT. chiropractors, OT, speech, massage. one inbox for scheduling, reminders, payments, and intake.
+I don't know anything about HIPAA and that scares me. also not sure if I should do this alone or find a cofounder who knows healthcare sales.
+we should never sell patient data or spam patients
+name idea: Kept

package/interface/harness/run.mjs

@@ -0,0 +1,313 @@
+#!/usr/bin/env node
+// The Naive agent harness (EE-054, EE-058, EE-059): takes a founder's idea dump through Discovery with
+// a real agent, start to end. The dump is not a prompt: it is every idea the founder has about the
+// venture, kept verbatim. Naive maps it onto its conventions (the idea map), asks its own product
+// questions first and fails closed on them, and decides what the agent sees and may do: need-now
+// picks the kit, the router gates every write, the agent's proposals wait for the founder, and routes
+// an open decision unlocks stay closed. The agent is one the founder already has (Claude Code,
+// headless); Naive holds no model key. Platform tools are handed to the agent beside Naive's own MCP
+// server, or spawned by path, never imported: Jev tags the ideas when TYPESAFE_API_KEY is set, and
+// Firecrawl researches the market when FIRECRAWL_API_KEY is set. With --money, the founder's money source
+// (Rho; its sandbox by default) fills the venture's money package, and the agent sees only its summary.
+//
+//   node interface/harness/run.mjs discovery --dump <ideas.md> [--id <slug>] [--name <name>] [--founder <name>]
+//        [--workspace <dir>] [--board] [--yes] [--steps <n>] [--money sandbox|live|<fixture.json>]
+//
+//   --board   serves the decision board at http://127.0.0.1:4331/ and the idea map at /map
+//   --yes     the founder settles the top-ranked decisions as worded (rehearsals and tests)
+//   --steps   how many decisions the founder settles between the agent's passes (default 3)
+//   --money   syncs money/ from Rho (sandbox, live with RHO_API_TOKEN, or a saved fixture) before pass 1
+//
+// 1. Naive maps the dump (Jev, else the agent tags it with the same conventions), then structures the
+//    map as an idea graph: a Merkle DAG with signal and lanes (EE-060).
+// 2. Pass 1: the agent reads the idea map, drafts answers to Naive's product questions and the problem
+//    record from the founder's own ideas, researches the market, and proposes the decisions the founder
+//    owes.
+// 3. The founder settles the top-ranked decisions, one at a time, in the order Naive ranks them.
+// 4. Pass 2: the agent assesses the accepted problem, does the work the decisions unlocked, and reports
+//    what comes next.
+// 5. Naive writes the venture package view: the packages open now, each record confirmed, to review or
+//    to write, what moves now and what waits (EE-067, EE-069). The founder confirms Mentura's
+//    understanding of the ideas between the graph and the agent's first pass (Understand, EE-069).
+
+import { spawn, spawnSync } from "node:child_process";
+import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, join, resolve } from "node:path";
+import { decisions } from "../../schema/decisions.mjs";
+import { docket } from "../../schema/docket.mjs";
+import { CONVENTIONS, DUMP, MAP, parse, render, split, summary, clean, request, fromAnswers } from "../../purpose/frameworks/idea-map/ideamap.mjs";
+import { GRAPH, build as buildGraph, request as graphRequest } from "../../purpose/frameworks/idea-map/graph.mjs";
+import { understood } from "../../purpose/frameworks/idea-map/route.mjs";
+import { createHash } from "node:crypto";
+import { agentFromEnv, record as prov } from "../provenance.mjs";
+import { evaluate } from "./evals.mjs";
+
+const repo = new URL("../../", import.meta.url).pathname;
+const argv = process.argv.slice(2);
+const opt = (n) => { const i = argv.indexOf(`--${n}`); return i >= 0 ? argv[i + 1] : undefined; };
+const flag = (n) => argv.includes(`--${n}`);
+const phase = argv[0];
+const dumpFile = opt("dump");
+if (phase !== "discovery" || !dumpFile || !existsSync(dumpFile)) {
+  console.error("usage: node interface/harness/run.mjs discovery --dump <ideas.md> [--id <slug>] [--name <name>] [--founder <name>] [--workspace <dir>] [--board] [--yes] [--steps <n>]");
+  process.exit(2);
+}
+const id = opt("id") ?? basename(dumpFile).replace(/\..*$/, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+const founder = opt("founder") ?? process.env.MENTURA_PERSON ?? "Founder";
+const ws = resolve(opt("workspace") ?? join(mkdtempSync(join(tmpdir(), "naive-run-")), "workspace"));
+const dir = join(ws, "ventures", id);
+const steps = Number(opt("steps") ?? 3);
+const jev = Boolean(process.env.TYPESAFE_API_KEY ?? process.env.TYPESAFEAI_API_KEY);
+const research = Boolean(process.env.FIRECRAWL_API_KEY);
+const t0 = Date.now();
+const laps = [];
+const lap = (what) => { const s = (Date.now() - t0) / 1000; laps.push({ at: s, what }); console.log(`\n[${s.toFixed(1)}s] ${what}`); };
+const cli = (...args) => spawnSync("node", [join(repo, "interface/cli/mentura.mjs"), ...args], { env: { ...process.env, MENTURA_WORKSPACE: ws }, encoding: "utf8" });
+
+// The venture, scaffolded by Naive, and the founder's dump, kept as they wrote it.
+if (!existsSync(join(dir, "venture.json"))) {
+  const p = spawnSync("node", [join(repo, "schema/init-venture.mjs"), dir, id, "--phase", phase], { encoding: "utf8" });
+  if (p.status !== 0) { console.error(p.stderr || p.stdout); process.exit(1); }
+  if (opt("name")) { const v = JSON.parse(readFileSync(join(dir, "venture.json"), "utf8")); v.name = opt("name"); writeFileSync(join(dir, "venture.json"), JSON.stringify(v, null, 2) + "\n"); }
+}
+mkdirSync(join(dir, "purpose/ideas"), { recursive: true });
+copyFileSync(dumpFile, join(dir, DUMP));
+prov(dir, { entity: DUMP, route: "purpose/idea-dump", activity: "create", agent: agentFromEnv("person", "harness", { id: founder }), note: "the founder's idea dump, verbatim" });
+lap(`venture ${id} scaffolded in ${ws}; idea dump saved (${readFileSync(dumpFile, "utf8").length} characters)`);
+
+// Money (EE-070): the money source stays the system of record. Naive syncs pointers and a summary into
+// the money data package; transactions stay in a sensitive stream that neither the agent nor the trace sees.
+let money = null;
+if (opt("money")) {
+  const m = opt("money");
+  const src = m === "live" ? ["--live"] : m === "sandbox" ? [] : ["--fixture", resolve(m)];
+  const p = spawnSync("node", [join(repo, "platform/integrations/rho.mjs"), "sync", "--venture", dir, ...src], { encoding: "utf8" });
+  if (p.status === 0 && existsSync(join(dir, "money/summary.json"))) {
+    money = JSON.parse(readFileSync(join(dir, "money/summary.json"), "utf8"));
+    prov(dir, { entity: "money/summary.json", route: "money/summary", activity: "create", agent: agentFromEnv("agent", "harness", { id: "naive-money" }), note: `synced from ${money.source}; ${money.transactions} transactions kept as pointers in a sensitive stream` });
+    lap(`money synced from ${money.source}${money.business ? ` (${money.business})` : ""}: cash ${(money.cash.amount / 100).toFixed(2)} ${money.cash.currency}, monthly net ${(money.monthly_net.amount / 100).toFixed(2)}, runway ${money.runway_months ?? "not limited by burn"}, as of ${money.as_of}`);
+  } else console.log(`   money sync failed, so the run goes on without it: ${(p.stderr || p.stdout).trim().slice(0, 300)}`);
+}
+
+const servers = { naive: { command: "node", args: [join(repo, "interface/mcp/server.mjs")], env: { MENTURA_WORKSPACE: ws, MENTURA_PERSON: founder } } };
+if (research) servers.research = { command: "node", args: [join(repo, "platform/mcp/research.mjs")], env: { FIRECRAWL_API_KEY: process.env.FIRECRAWL_API_KEY } };
+const mcp = join(ws, ".mcp-harness.json");
+writeFileSync(mcp, JSON.stringify({ mcpServers: servers }));
+
+let board = null;
+if (flag("board")) { process.env.MENTURA_WORKSPACE = ws; board = (await import("../demo/board.mjs")).serve(4331, id); console.log("Decision board: http://127.0.0.1:4331/   Idea map: http://127.0.0.1:4331/map"); }
+
+// The trace (EE-058): every step and every tool call the agent made, with timings, for LangSmith.
+const iso = () => new Date().toISOString();
+const trace = { name: `naive discovery: ${id}`, run_type: "chain", start: iso(), inputs: { dump: DUMP, ideas: readFileSync(join(dir, DUMP), "utf8"), founder, phase }, children: [], metadata: {
+  venture: id, venture_id: id, pipeline_step: phase, money: money?.source ?? null,
+  // LangSmith groups a founder's runs into one thread by thread_id: one session per venture per day.
+  thread_id: process.env.NAIVE_SESSION ?? `${id}-${new Date().toISOString().slice(0, 10)}`,
+  harness_version: spawnSync("git", ["rev-parse", "--short", "HEAD"], { cwd: repo, encoding: "utf8" }).stdout.trim() || null,
+} };
+const researched = [];
+if (money) trace.children.push({ name: "money: sync", run_type: "tool", start: iso(), end: iso(), inputs: { source: money.source }, outputs: { summary: money } });
+
+// The agent runs headless and streams what it does; each tool call becomes a child run.
+async function agent(prompt, label, { tools = "mcp__naive__*,mcp__research__*", quiet = false } = {}) {
+  lap(`agent: ${label}`);
+  const node = { name: label, run_type: "chain", start: iso(), inputs: { prompt }, children: [] };
+  trace.children.push(node);
+  // No built-in tools (no shell, no file access): the agent works only through the MCP servers it is handed.
+  const args = ["-p", prompt, "--output-format", "stream-json", "--verbose", "--tools", "", ...(tools ? ["--mcp-config", mcp, "--strict-mcp-config", "--allowedTools", tools] : ["--strict-mcp-config"])];
+  const child = spawn("claude", args, { stdio: ["ignore", "pipe", "inherit"], env: { ...process.env, MENTURA_WORKSPACE: ws } });
+  const open = new Map();
+  let result = null, buf = "";
+  child.stdout.on("data", (chunk) => {
+    buf += chunk;
+    let nl;
+    while ((nl = buf.indexOf("\n")) >= 0) {
+      const line = buf.slice(0, nl); buf = buf.slice(nl + 1);
+      let ev; try { ev = JSON.parse(line); } catch { continue; }
+      for (const c of ev.message?.content ?? []) {
+        if (c.type === "tool_use") {
+          const t = { name: c.name.replace(/^mcp__/, ""), run_type: "tool", start: iso(), inputs: c.input ?? {}, children: [] };
+          open.set(c.id, t); node.children.push(t);
+          if (!quiet) console.log(`   > ${t.name}${c.input?.route ? ` ${c.input.route}` : c.input?.queries ? ` ${JSON.stringify(c.input.queries)}` : c.input?.id ? ` ${c.input.id}` : ""}`);
+        } else if (c.type === "tool_result" && open.has(c.tool_use_id)) {
+          const t = open.get(c.tool_use_id);
+          const text = Array.isArray(c.content) ? c.content.map((x) => x.text ?? "").join("") : String(c.content ?? "");
+          Object.assign(t, { end: iso(), outputs: { result: text.slice(0, 20000) }, ...(c.is_error ? { error: text.slice(0, 2000) } : {}) });
+          if (t.name.startsWith("research__")) for (const m of text.matchAll(/"url":\s*"([^"]+)"/g)) researched.push(m[1]);
+        }
+      }
+      if (ev.type === "result") result = ev;
+    }
+  });
+  const code = await new Promise((r) => child.on("close", r));
+  if (code !== 0 || !result || result.is_error) {
+    // Say why: the reason is in the agent's own result (an expired login, a refused tool), not in its exit code.
+    const why = (result?.result ?? "").trim();
+    node.error = `the agent stopped with status ${code}${why ? `: ${why}` : ""}${/log ?in|\/login|authenticat/i.test(why) ? " (run claude, then /login, and start again)" : ""}`;
+    console.error(node.error); finish(1); if (!board) process.exit(1); await new Promise(() => {});
+  }
+  Object.assign(node, { end: iso(), outputs: { report: result.result }, metadata: { cost_usd: result.total_cost_usd, turns: result.num_turns, usage: result.usage } });
+  if (!quiet) console.log(result.result.trim().split("\n").map((l) => `   ${l}`).join("\n"));
+  return result.result;
+}
+
+// The run's evals and trace: written beside the workspace, and sent to LangSmith when a key is set.
+function finish(code = 0) {
+  trace.end = iso();
+  const evals = existsSync(join(dir, DUMP)) ? evaluate(dir, { researched, settled }) : [];
+  trace.feedback = evals;
+  // What the run drafted, so a judge reading only the root run (LangSmith's online evaluators, Jev)
+  // sees the problem record and the agent's reports beside the founder's dump in the inputs.
+  const problem = join(dir, "purpose/validation/problem.json");
+  const drafted = { problem: existsSync(problem) ? JSON.parse(readFileSync(problem, "utf8")) : null, reports: trace.children.filter((c) => c.outputs?.report).map((c) => ({ pass: c.name, report: c.outputs.report })) };
+  trace.outputs = { settled, docket: { steps: docketSteps, now: compact(docket(dir)) }, drafted, evals: Object.fromEntries(evals.map((e) => [e.key, e.score])), laps };
+  writeFileSync(join(ws, "trace.json"), JSON.stringify(trace, null, 2) + "\n");
+  console.log(`\nEvals:\n${evals.map((e) => `   ${e.score === 1 ? "pass" : e.score === 0 ? "FAIL" : "part"}  ${e.key.padEnd(26)} ${e.score}  ${e.comment}`).join("\n")}`);
+  if (process.env.LANGSMITH_API_KEY) {
+    const p = spawnSync("node", [join(repo, "platform/integrations/langsmith.mjs"), join(ws, "trace.json")], { encoding: "utf8" });
+    console.log(p.status === 0 ? `LangSmith: ${p.stdout.trim()}` : `LangSmith upload failed: ${(p.stderr || p.stdout).trim()}`);
+  }
+  // The board keeps serving the finished run, or the stopped one, so the founder can see where it got to.
+  if (board) { console.log(`\nThe board keeps serving${code ? " what the run got to" : ""}: http://127.0.0.1:4331/ and /map. Ctrl-C to stop. Workspace: ${ws}`); return; }
+  board?.close();
+  process.exit(code);
+}
+const settled = [];
+const docketSteps = [];
+const compact = (k) => ({ leading: k.functions[0]?.function ?? null, functions: k.functions.map((f) => ({ function: f.function, attention: f.attention,
+  decisions: f.decisions.slice(0, 3).map((d) => ({ id: d.id, question: d.question, value: d.value, dominant: d.dominant, why: d.why })) })) });
+
+// 1. The idea map: Jev tags each idea with Naive's conventions; without Jev, the agent does, with the
+//    same vocabulary. Either way the ideas stay verbatim and unknown tags are dropped.
+const ideas = split(readFileSync(join(dir, DUMP), "utf8"));
+const venture = JSON.parse(readFileSync(join(dir, "venture.json"), "utf8"));
+let tags, tagger;
+const mapNode = { name: "idea map", run_type: "tool", start: iso(), inputs: { ideas: ideas.length }, children: [] };
+if (jev) {
+  const p = spawnSync("node", [join(repo, "platform/integrations/jev.mjs")], { input: JSON.stringify(request(ideas, venture)), encoding: "utf8", maxBuffer: 1 << 26 });
+  if (p.status !== 0) { console.error(p.stderr); process.exit(1); }
+  const out = JSON.parse(p.stdout);
+  tags = fromAnswers(out.answers);
+  tagger = out.model ?? "jev";
+  console.log(`   Jev answered ${Object.keys(out.answers).length} typed questions in ${out.ms} ms (${out.requests} requests)`);
+} else {
+  const text = await agent(`Tag each idea below with Naive's conventions. Answer with JSON only, no prose: {"<idea id>": {"departments": [...], "records": [...], "exists": true|false}}.
+departments (at most ${CONVENTIONS.max.departments}, the ones the idea is mainly about): ${JSON.stringify(CONVENTIONS.departments)}
+records (at most ${CONVENTIONS.max.records}, the ones it mainly feeds): ${JSON.stringify(Object.fromEntries(Object.entries(CONVENTIONS.records).map(([k, v]) => [k, v.about])))}
+exists: true only if ${CONVENTIONS.exists}.
+Ideas: ${JSON.stringify(Object.fromEntries(ideas.map((i) => [i.id, i.section ? `[${i.section}] ${i.text}` : i.text])))}`, "tagging the ideas (no Jev key)", { tools: null, quiet: true });
+  tags = JSON.parse(text.slice(text.indexOf("{"), text.lastIndexOf("}") + 1));
+  tagger = "claude-code";
+}
+writeFileSync(join(dir, MAP), render(ideas, clean(tags), { venture: id, tagger }));
+prov(dir, { entity: MAP, route: "purpose/idea-map", activity: "create", derived_from: [DUMP], agent: agentFromEnv("agent", "harness", { id: tagger }), note: `${ideas.length} ideas tagged with Naive's conventions` });
+const sum = summary(parse(readFileSync(join(dir, MAP), "utf8")), phase);
+trace.children.push(Object.assign(mapNode, { end: iso(), outputs: { tagger, summary: sum }, metadata: { tagger } }));
+lap(`idea map: ${sum.ideas} ideas; ${Object.entries(sum.by_pillar).map(([k, v]) => `${k} ${v}`).join(", ")}; clusters ${sum.strengths.map((s) => s.department).join(", ")}; ${sum.product.reading}`);
+
+// 1b. The idea graph: the map's structured form. Jev judges which ideas build on which; without Jev,
+//     Naive's record order does. Signal, lanes and layout follow in code.
+const graphNode = { name: "idea graph", run_type: "tool", start: iso(), inputs: { ideas: ideas.length }, children: [] };
+const mapIdeas = parse(readFileSync(join(dir, MAP), "utf8")).ideas;
+let graphAnswers = null;
+if (jev) {
+  const p = spawnSync("node", [join(repo, "platform/integrations/jev.mjs")], { input: JSON.stringify(graphRequest(mapIdeas, venture)), encoding: "utf8", maxBuffer: 1 << 26 });
+  if (p.status === 0) { const out = JSON.parse(p.stdout); graphAnswers = out.answers; console.log(`   Jev answered ${Object.keys(out.answers).length} dependency and concreteness questions in ${out.ms} ms`); }
+  else console.log(`   Jev could not judge the dependencies (${p.stderr.trim().slice(0, 200)}); using Naive's record order`);
+}
+const g = buildGraph(mapIdeas, { answers: graphAnswers, phase, venture: id, source: `${MAP}@${createHash("sha256").update(readFileSync(join(dir, MAP))).digest("hex").slice(0, 16)}` });
+writeFileSync(join(dir, GRAPH), JSON.stringify(g, null, 2) + "\n");
+prov(dir, { entity: GRAPH, route: "purpose/idea-graph", activity: "create", derived_from: [MAP], agent: agentFromEnv("agent", "harness", { id: g.judged_by }), note: `Merkle root ${g.root}` });
+trace.children.push(Object.assign(graphNode, { end: iso(), outputs: { root: g.root, edges: g.edges.length, lanes: g.lanes.map((l) => ({ mode: l.mode, ideas: l.ideas.length })), next: g.next } }));
+lap(`idea graph: ${g.edges.length} dependencies (${g.judged_by}); ${g.lanes.filter((l) => l.mode === "sync").length} lane(s) in order, ${g.lanes.filter((l) => l.mode === "async").length} on their own; develop next: ${g.next.join(", ")}; root ${g.root}`);
+
+// 1c. Understand (EE-069): the founder confirms Mentura read their ideas right, after correcting the
+//     map or the graph, before anything is routed.
+if (flag("yes")) {
+  const u = cli("understand", "--venture", id, "--confirm", "ideas", "--note", "rehearsal: confirmed as mapped");
+  if (u.status !== 0) { console.error(u.stderr || u.stdout); process.exit(1); }
+} else {
+  lap("waiting for the founder to confirm the understanding of their ideas (mentura understand)");
+  while (!understood(dir)) await new Promise((r) => setTimeout(r, 1000));
+}
+trace.children.push({ name: "founder: understand", run_type: "chain", start: iso(), end: iso(), inputs: { map: MAP, graph: GRAPH }, outputs: { understood: true } });
+lap("the founder confirmed Mentura's understanding of the ideas; routing them");
+
+const rules = `You are the builder agent (agent_id builder) for the venture ${id}. Work only through the naive MCP tools${research ? " and the research tools" : ""}; pass agent_id "builder" on every naive call.
+Rules: the founder's idea dump is theirs. Quote it, cite ideas by id (i-01...), never put words in their mouth. Never invent evidence: every evidence item cites a URL a research result gave you${research ? "" : " (you have no research tool in this run, so leave evidence empty and say so)"}. Records Naive treats as the founder's are written as drafts for the founder to accept; that is expected. You never decide; you propose. knowledge/venture-profile cannot be written over MCP; skip it.${money ? `
+Money: Naive synced the venture's money summary from ${money.source}, the system of record (money/summary.json): ${JSON.stringify(money)}. Amounts are in minor units (cents). Any proposal or record that touches money (pricing, spend, hiring, runway, fundraising) cites "money/summary.json as of ${money.as_of}" and uses only the figures the summary gives; never estimate the founder's finances.` : ""}`;
+
+await agent(`${rules}
+The founder has just submitted an idea dump. Naive mapped it onto its conventions.
+1. mentura_run purpose/ideas: read every idea, where they cluster and what the dump never mentions. mentura_run purpose/ideas/graph: which ideas build on which, the lanes that move in order and the ones that can move on their own, and the highest-signal ideas to develop next. mentura_run purpose/ideas/routes: where each idea goes in the framework, each destination's stage and its next step. Then mentura_decisions: Naive's own product questions come first (product-exists, then core-product, then flagship) and fail closed.
+2. Propose an answer to product-exists with mentura_propose_decision (id "product-exists", at "products", name "product.exists", same question), worded from the ideas tagged exists and citing them by id. Do not change its parent, boundary or unlocks.
+2b. If the dump says anything about a team or cofounders, propose wording for founding-team (id "founding-team", at "", name "venture.team", same question), starting with Solo, Cofounders or Looking and quoting the idea; if it says nothing, leave it for the founder.
+3. Write the problem record (purpose/validation/problem) from the founder's ideas: the problem in their words, who has it, and the assumptions to test. Read mentura_layout first.${research ? `
+4. Research the market with research_search: existing alternatives and competitors the dump names or implies, prices, and people describing the problem. Add what you find to the problem record as evidence with URLs.` : ""}
+5. Propose two or three more decisions the founder owes from what the dump leaves open (at "purpose/validation", name "problem.<topic>"), each with your proposed answer, the ids of the ideas it comes from in "ideas", a due time within 72 hours if urgent, one or two projected outcomes, and unlocks for ["builder"].
+6. mentura_decisions and report, in at most eight lines: what the idea map shows (clusters and gaps), your answer to product-exists, what the evidence supports, and the founder's decisions in rank order.`, "pass 1: idea map, product questions, problem, research, proposals");
+
+// 3. The founder settles what the docket ranks first, one decision at a time (EE-075): the function that
+//    needs attention most, then its highest-value decision the founder can settle now. Each step's docket
+//    goes in the trace, so a judge can check that the ranking was the right next step.
+for (let n = 0; n < steps; n++) {
+  const r = decisions(dir);
+  const k = docket(dir);
+  const pick = k.functions.flatMap((f) => f.decisions).find((d) => d.action && ["decide", "accept", "confirm"].includes(d.action.kind) && !settled.includes(d.id));
+  const next = pick && r.decisions.find((d) => d.id === pick.id);
+  if (!next) break;
+  next.why = pick.why;
+  docketSteps.push({ step: n + 1, ...compact(k), chose: pick.id });
+  trace.children.push({ name: `docket: step ${n + 1}`, run_type: "chain", start: iso(), end: iso(), inputs: { venture: id }, outputs: docketSteps.at(-1) });
+  lap(`docket: ${k.functions.map((f) => `${f.function} ${f.attention}`).join(" · ")}; next ${pick.id} (${pick.function}, value ${pick.value}${pick.dominant ? ", outweighs every other function" : ""})`);
+  console.log(`\nFOUNDER #${n + 1}: ${next.id}: ${next.question}\n         Why now: ${(next.why ?? []).join("; ")}${next.answer ? `\n         Proposed: ${next.answer}` : ""}\n         ${next.action.command.replace(/^mentura /, `MENTURA_WORKSPACE=${ws} node ${join(repo, "interface/cli/mentura.mjs")} `)}`);
+  const before = JSON.stringify(r.decisions.find((d) => d.id === next.id));
+  if (flag("yes")) {
+    const a = next.action;
+    const p = a.kind === "decide" ? cli("decide", next.id, "--venture", id, "--by", founder, ...(next.answer ? [] : ["--answer", "Not yet: it is still an idea"]), "--confirm", a.confirm)
+      : a.kind === "accept" ? cli("accept", a.route, "--venture", id, "--confirm", a.confirm) : cli("confirm", a.statement, "--venture", id, "--confirm", a.confirm);
+    if (p.status !== 0) { console.error(`   could not settle ${next.id}: ${(p.stderr || p.stdout).trim()}`); settled.push(next.id); continue; }
+  } else {
+    lap(`waiting for the founder to settle ${next.id}`);
+    while (JSON.stringify(decisions(dir).decisions.find((d) => d.id === next.id)) === before) await new Promise((r) => setTimeout(r, 1000));
+  }
+  settled.push(next.id);
+  const now = decisions(dir).decisions.find((d) => d.id === next.id);
+  trace.children.push({ name: `founder: ${next.id}`, run_type: "chain", start: iso(), end: iso(), inputs: { question: next.question, why: next.why, proposed: next.answer ?? null, action: next.action.kind }, outputs: { status: now?.status, provenance: now?.provenance ?? null } });
+  lap(`${next.id} settled${now?.provenance?.approved_by ? ` by ${now.provenance.approved_by} (${now.provenance.wording} the wording)` : ""}`);
+}
+if (!settled.length) { lap("nothing for the founder to settle; stopping"); finish(1); process.exit(1); }
+
+// 4. The work the founder's decisions unlocked.
+await agent(`${rules}
+The founder settled: ${settled.join(", ")}. mentura_decisions shows what that unlocked. First, if the founder accepted the problem record, mentura_run purpose/validation/assess with as_is true and note what the evidence supports. Then do the work the decisions unlock for you: if product-exists is decided, write product cards (purpose/product/<id>) for what exists or is planned, from the founder's ideas, citing them; then propose wording for core-product with mentura_propose_decision (id "core-product", at "products", name "product.core", the same question; mentura_decisions shows it), from the ideas tagged venture-core, citing them. Then mentura_run purpose/ideas/routes and draft the highest-signal destination still in Routed that moves in order and has no record yet (not the problem, not products), from its ideas, citing them. Then mentura_decisions again and report in at most six lines: what the assessment says, what you did, and the founder's next decision with why it ranks first.`, "pass 2: the work the decisions unlocked");
+
+// 5. The venture package (EE-067, EE-069): the question matrix settles which packages are open (Jev
+//    answers what the records leave open), and the view shows each package's state, what moves now and
+//    what waits. The sitemap is a marketing record: it is planned only once the marketing package is open.
+let pkgArgs = [];
+if (jev) {
+  const rq = spawnSync("node", [join(repo, "schema/packages.mjs"), "request", dir], { encoding: "utf8" });
+  const q = rq.status === 0 ? JSON.parse(rq.stdout) : null;
+  if (q && Object.keys(q.questions).length) {
+    const p = spawnSync("node", [join(repo, "platform/integrations/jev.mjs")], { input: JSON.stringify(q), encoding: "utf8" });
+    if (p.status === 0) { writeFileSync(join(ws, "package-answers.json"), p.stdout); pkgArgs = ["--answers", join(ws, "package-answers.json")]; console.log(`   Jev answered ${Object.keys(q.questions).length} of the question matrix's questions`); }
+  }
+}
+let pk = spawnSync("node", [join(repo, "schema/packages.mjs"), dir, ...pkgArgs, "--json"], { encoding: "utf8" });
+if (pk.status === 0 && JSON.parse(pk.stdout).core.some((x) => x.id === "marketing" && x.in === "now")) {
+  const sp = spawnSync("node", [join(repo, "operations/marketing/site/plan.mjs"), dir, "--write"], { encoding: "utf8" });
+  if (sp.status === 0) prov(dir, { entity: "operations/marketing/sitemap.json", route: "operations/marketing/sitemap", activity: "create", derived_from: ["purpose/icp.json", "products/"], agent: agentFromEnv("agent", "harness", { id: "naive-planner" }), note: "the site planned from the venture's records: the marketing package is open" });
+}
+pk = spawnSync("node", [join(repo, "schema/packages.mjs"), dir, ...pkgArgs, "--write", "--json"], { encoding: "utf8" });
+if (pk.status === 0) {
+  const r = JSON.parse(pk.stdout);
+  const open = r.core.filter((x) => x.in === "now");
+  trace.children.push({ name: "venture package", run_type: "tool", start: iso(), end: iso(), inputs: { phase: r.phase }, outputs: { progress: r.progress, open: open.map((x) => ({ id: x.id, state: x.state, progress: x.progress, moving: x.moving, missing: x.missing })), questions_open: r.situation.questions.filter((x) => x.value == null).map((x) => x.id) } });
+  lap(`venture package: ${Math.round(r.progress * 100)}% across ${open.map((x) => `${x.title} (${x.state}, ${Math.round(x.progress * 100)}%)`).join(", ")}; next phase: ${r.core.filter((x) => x.in === "next").map((x) => x.title).join(", ") || "none"}; view in ${join(dir, "package")}`);
+} else console.log(`   the venture package failed: ${pk.stderr.trim().slice(0, 300)}`);
+
+const end = decisions(dir);
+lap(`done. ${end.decisions.filter((d) => d.source === "file").length} decision records, ${end.decisions.filter((d) => d.rank != null).length} ranked for the founder, ${settled.length} settled; workspace ${ws}`);
+finish(0);