@teurons/vds 0.0.7 → 0.0.8

package/dist/CHANGELOG.md

@@ -11,7 +11,28 @@ Each release has two parts:
   and the one it installed.
   "None" means there is nothing to do.
 
-## 0.0.7 (2026-11-02)
+## 0.0.8 (2026-11-03)
+
+### What changed
+
+- Flows are now journeys. The folder is `journeys/<id>.yaml`, the top key is `journey:`, and every
+  journey file names its kind with `kind: journey` (the checker refuses a missing or unknown kind).
+  In states, `next_flow` is `next_journey` and the `subflow` type is `subjourney`. The index, checker
+  codes (`journey_*`), studio pages (`/journeys/<id>`), MCP tools (`vds_mark_built(journey)`), the
+  command (`vds built <journey>`) and VDS.md all say journey. `vds update` moves `flows/` to
+  `journeys/` and rewrites the keys, including in `versions/`, and prints each file. `vds check` on a
+  workspace that still has `flows/` and no `journeys/` tells you to run `vds update`.
+- The studio's "Group by capability" works: the server now passes the page its full address. Each
+  journey on the dashboard shows its id. An empty workspace shows this studio's own MCP address
+  instead of `<port>`. Changelog entries are dated in the maintainer's local time.
+
+### Agent steps
+
+- Run `npx -y @teurons/vds@latest update`; it moves flows/ to journeys/ for you and prints each file.
+- Change the wording from flow to journey in the project's AGENTS.md and CLAUDE.md, and re-read VDS.md.
+- Rename tests named after FLOW-xx scenario ids only if the workspace is VDS's own (FLOW is now JRN); other workspaces keep their ids.
+
+## 0.0.7 (2026-11-03)
 
 ### What changed
 

package/dist/vds.js

@@ -7510,17 +7510,17 @@ function stateRules(state) {
     ...(state.choices ?? []).flatMap((c) => c.requirements ?? [])
   ];
 }
-function ruleIdsOf(flow) {
-  return new Set(Object.values(flow.states ?? {}).flatMap(stateRules));
+function ruleIdsOf(journey) {
+  return new Set(Object.values(journey.states ?? {}).flatMap(stateRules));
 }
-function flowsOf(files) {
-  return Object.keys(files).filter((p) => p.startsWith("flows/") && p.endsWith(".yaml")).sort().map((path) => {
-    const flow = (0, import_yaml.parse)(files[path]) ?? {};
-    return { path, id: flow.flow ?? path.slice(6, -5), flow };
+function journeysOf(files) {
+  return Object.keys(files).filter((p) => p.startsWith("journeys/") && p.endsWith(".yaml")).sort().map((path) => {
+    const journey = (0, import_yaml.parse)(files[path]) ?? {};
+    return { path, id: journey.journey ?? path.slice(6, -5), journey };
   });
 }
-function isBuilt(flow) {
-  return !flow.built || flow.built.version === flow.version;
+function isBuilt(journey) {
+  return !journey.built || journey.built.version === journey.version;
 }
 function inline(doc, value) {
   const node2 = doc.createNode(value);
@@ -7529,11 +7529,11 @@ function inline(doc, value) {
 }
 function recordChange(text, rule, at) {
   const doc = (0, import_yaml.parseDocument)(text);
-  const flow = doc.toJS();
+  const journey = doc.toJS();
   const writes = {};
-  if (isBuilt(flow)) {
-    writes.old = { version: flow.version, text };
-    doc.set("version", flow.version + 1);
+  if (isBuilt(journey)) {
+    writes.old = { version: journey.version, text };
+    doc.set("version", journey.version + 1);
   }
   const change = inline(doc, { version: doc.get("version"), rule, at });
   const changes = doc.get("changes");
@@ -7547,8 +7547,8 @@ function impact(before, after, at = today()) {
   const affected = [];
   const unaffected = [];
   const moved = {};
-  for (const { path, id, flow } of flowsOf(after)) {
-    const used = ruleIdsOf(flow);
+  for (const { path, id, journey } of journeysOf(after)) {
+    const used = ruleIdsOf(journey);
     const hits = rules.filter((r) => used.has(r));
     if (hits.length === 0) {
       unaffected.push(id);
@@ -7566,17 +7566,17 @@ function impact(before, after, at = today()) {
   }
   return { writes, affected, unaffected, rules, moved };
 }
-function markBuilt(files, flowId, by, at = today()) {
-  const found = flowsOf(files).find((f) => f.id === flowId);
+function markBuilt(files, journeyId, by, at = today()) {
+  const found = journeysOf(files).find((f) => f.id === journeyId);
   if (!found) return null;
   const doc = (0, import_yaml.parseDocument)(files[found.path]);
-  doc.set("built", inline(doc, { version: found.flow.version, by, at }));
+  doc.set("built", inline(doc, { version: found.journey.version, by, at }));
   return { [found.path]: String(doc) };
 }
-function versionsOf(files, flowId) {
-  const kept = Object.keys(files).map((p) => p.match(new RegExp(`^versions/${flowId}/v(\\d+)\\.yaml$`))).filter(Boolean).map((m) => ({ version: Number(m[1]), text: files[m[0]] }));
-  const current = flowsOf(files).find((f) => f.id === flowId);
-  if (current) kept.push({ version: current.flow.version, text: files[current.path] });
+function versionsOf(files, journeyId) {
+  const kept = Object.keys(files).map((p) => p.match(new RegExp(`^versions/${journeyId}/v(\\d+)\\.yaml$`))).filter(Boolean).map((m) => ({ version: Number(m[1]), text: files[m[0]] }));
+  const current = journeysOf(files).find((f) => f.id === journeyId);
+  if (current) kept.push({ version: current.journey.version, text: files[current.path] });
   return kept.sort((a, b) => a.version - b.version);
 }
 function diffState(id, was, now) {
@@ -7593,7 +7593,7 @@ function diffState(id, was, now) {
   const differs = entry.titleChanged || !sameShape(was, now, before, after);
   return { ...entry, status: differs ? "changed" : "same" };
 }
-function compareFlows(aText, bText) {
+function compareJourneys(aText, bText) {
   const a = (0, import_yaml.parse)(aText)?.states ?? {};
   const b = (0, import_yaml.parse)(bText)?.states ?? {};
   return [.../* @__PURE__ */ new Set([...Object.keys(b), ...Object.keys(a)])].map(
@@ -7623,8 +7623,8 @@ function whoIsBuilding() {
   }
   return process.env.USER || process.env.USERNAME || "unknown";
 }
-function builtWrites(files, flowId) {
-  return markBuilt(files, flowId, whoIsBuilding());
+function builtWrites(files, journeyId) {
+  return markBuilt(files, journeyId, whoIsBuilding());
 }
 function writeAll(root, writes) {
   for (const [path, text] of Object.entries(writes)) {
@@ -7735,45 +7735,45 @@ var init_evidence = __esm({
 });
 
 // src/workspace.js
-import { readdirSync as readdirSync2, readFileSync as readFileSync6 } from "node:fs";
-import { join as join5 } from "node:path";
+import { readdirSync as readdirSync3, readFileSync as readFileSync7 } from "node:fs";
+import { join as join6 } from "node:path";
 function readWorkspace(root) {
   const files = {};
-  for (const dir of FOLDERS2) {
+  for (const dir of [...FOLDERS2, "flows"]) {
     let names = [];
     try {
-      names = readdirSync2(join5(root, dir));
+      names = readdirSync3(join6(root, dir));
     } catch {
       continue;
     }
-    for (const name of names) files[`${dir}/${name}`] = readFileSync6(join5(root, dir, name), "utf8");
+    for (const name of names) files[`${dir}/${name}`] = readFileSync7(join6(root, dir, name), "utf8");
   }
   return Object.assign(files, readVersions(root));
 }
 function readVersions(root) {
   const files = {};
-  let flows = [];
+  let journeys = [];
   try {
-    flows = readdirSync2(join5(root, "versions"));
+    journeys = readdirSync3(join6(root, "versions"));
   } catch {
     return files;
   }
-  for (const id of flows) {
+  for (const id of journeys) {
     let names = [];
     try {
-      names = readdirSync2(join5(root, "versions", id));
+      names = readdirSync3(join6(root, "versions", id));
     } catch {
       continue;
     }
     for (const n of names.filter((x) => x.endsWith(".yaml")))
-      files[`versions/${id}/${n}`] = readFileSync6(join5(root, "versions", id, n), "utf8");
+      files[`versions/${id}/${n}`] = readFileSync7(join6(root, "versions", id, n), "utf8");
   }
   return files;
 }
 var FOLDERS2;
 var init_workspace = __esm({
   "src/workspace.js"() {
-    FOLDERS2 = ["capabilities", "flows", "scenarios"];
+    FOLDERS2 = ["capabilities", "journeys", "scenarios"];
   }
 });
 
@@ -7783,12 +7783,12 @@ __export(server_exports, {
   portFor: () => portFor,
   startServer: () => startServer
 });
-import { readFileSync as readFileSync7, watch } from "node:fs";
+import { readFileSync as readFileSync8, watch } from "node:fs";
 import { createServer as createServer2 } from "node:http";
-import { join as join6 } from "node:path";
+import { join as join7 } from "node:path";
 function portFor(root) {
   try {
-    const { port } = JSON.parse(readFileSync7(join6(root, ".vds.json"), "utf8"));
+    const { port } = JSON.parse(readFileSync8(join7(root, ".vds.json"), "utf8"));
     return Number.isInteger(port) ? port : FIRST_PORT2;
   } catch {
     return FIRST_PORT2;
@@ -7837,7 +7837,8 @@ async function startServer({
         return;
       }
       const files = readWorkspace(root);
-      const { status, html } = render(pathname, files, check4(files), loadEvidence(root));
+      const address = new URL(req.url, `http://${req.headers.host ?? "localhost"}`).href;
+      const { status, html } = render(address, files, check4(files), loadEvidence(root));
       res.writeHead(status, { "content-type": "text/html; charset=utf-8" });
       res.end(withReloadScript(html));
     } catch (e) {
@@ -7885,37 +7886,37 @@ var init_server = __esm({
 });
 
 // src/studio/versionPages.js
-function withVersionInfo(flows, files) {
-  const info = flows.map((flow) => {
-    const raw = (0, import_yaml2.parse)(files[`flows/${flow.id}.yaml`] ?? "") ?? {};
-    const versions = versionsOf(files, flow.id).map((v) => v.version);
+function withVersionInfo(journeys, files) {
+  const info = journeys.map((journey) => {
+    const raw = (0, import_yaml2.parse)(files[`journeys/${journey.id}.yaml`] ?? "") ?? {};
+    const versions = versionsOf(files, journey.id).map((v) => v.version);
     return {
-      ...flow,
+      ...journey,
       vinfo: { built: raw.built, changes: raw.changes ?? [], versions, unbuilt: !isBuilt(raw) }
     };
   });
   return [...info.filter((f) => f.vinfo.unbuilt), ...info.filter((f) => !f.vinfo.unbuilt)];
 }
-function changedBadge(flow, m, { esc: esc3, plainOf: plainOf2 }) {
-  if (!flow.vinfo?.unbuilt) return "";
+function changedBadge(journey, m, { esc: esc3, plainOf: plainOf2 }) {
+  if (!journey.vinfo?.unbuilt) return "";
   const rules = [
     ...new Set(
-      flow.vinfo.changes.filter((c) => c.version > (flow.vinfo.built?.version ?? 0)).map((c) => c.rule)
+      journey.vinfo.changes.filter((c) => c.version > (journey.vinfo.built?.version ?? 0)).map((c) => c.rule)
     )
   ];
   const lines = rules.map((id) => m.rules.has(id) ? plainOf2(m.rules.get(id)) : id);
-  return `<div class="changed"><b>Changed</b> \xB7 v${esc3(flow.version)} is not built yet${lines.length ? `: ${lines.map(esc3).join("; ")}` : ""}</div>`;
+  return `<div class="changed"><b>Changed</b> \xB7 v${esc3(journey.version)} is not built yet${lines.length ? `: ${lines.map(esc3).join("; ")}` : ""}</div>`;
 }
-function defaultPair(flow) {
-  const { versions, built } = flow.vinfo;
-  const current = flow.version;
+function defaultPair(journey) {
+  const { versions, built } = journey.vinfo;
+  const current = journey.version;
   const before = built && built.version < current ? built.version : versions.filter((v) => v < current).at(-1);
   return [before, current];
 }
-function compareLink(flow) {
-  if (!flow.vinfo || flow.vinfo.versions.length < 2) return "";
-  const [a, b] = defaultPair(flow);
-  return ` \xB7 <a href="/flows/${encodeURIComponent(flow.id)}/compare?a=${a}&amp;b=${b}">Compare versions</a>`;
+function compareLink(journey) {
+  if (!journey.vinfo || journey.vinfo.versions.length < 2) return "";
+  const [a, b] = defaultPair(journey);
+  return ` \xB7 <a href="/journeys/${encodeURIComponent(journey.id)}/compare?a=${a}&amp;b=${b}">Compare versions</a>`;
 }
 function rowOf(d, m, tools) {
   const { esc: esc3, plainOf: plainOf2 } = tools;
@@ -7929,25 +7930,25 @@ function rowOf(d, m, tools) {
   const tag = LABELS[d.status] ? ` <span class="tag">${LABELS[d.status]}</span>` : "";
   return `<li class="diff ${d.status}"><b>${name}</b>${tag}${notes.length ? `<small>${notes.join("<br>")}</small>` : ""}</li>`;
 }
-function compareRoute(flow, m, query, tools) {
-  if (!flow.vinfo || flow.vinfo.versions.length < 2) return void 0;
-  const [a0, b0] = defaultPair(flow);
+function compareRoute(journey, m, query, tools) {
+  if (!journey.vinfo || journey.vinfo.versions.length < 2) return void 0;
+  const [a0, b0] = defaultPair(journey);
   const a = Number(query.get("a") ?? a0);
   const b = Number(query.get("b") ?? b0);
-  const kept = versionsOf(m.files, flow.id);
+  const kept = versionsOf(m.files, journey.id);
   const [va, vb] = [a, b].map((n) => kept.find((v) => v.version === n));
   if (!va || !vb) return void 0;
-  const rows = compareFlows(va.text, vb.text);
+  const rows = compareJourneys(va.text, vb.text);
   const { esc: esc3 } = tools;
   const shown = rows.map((r) => rowOf(r, m, tools));
-  const body = `<p class="sub"><a href="/flows/${encodeURIComponent(flow.id)}">${esc3(flow.title)}</a></p>
+  const body = `<p class="sub"><a href="/journeys/${encodeURIComponent(journey.id)}">${esc3(journey.title)}</a></p>
 <h1>Compare versions</h1><p class="sub">Version ${a} against Version ${b}: what was added, removed or changed.</p>
 <ul class="list">${shown.join("")}</ul>`;
-  return { title: `${flow.title}: versions`, body };
+  return { title: `${journey.title}: versions`, body };
 }
 function versionModel(m, files) {
-  const flows = withVersionInfo(m.flows, files);
-  return { ...m, files, flows, flowById: new Map(flows.map((f) => [f.id, f])) };
+  const journeys = withVersionInfo(m.journeys, files);
+  return { ...m, files, journeys, journeyById: new Map(journeys.map((f) => [f.id, f])) };
 }
 var import_yaml2, LABELS;
 var init_versionPages = __esm({
@@ -7974,7 +7975,7 @@ function layout(title, body, findings) {
   return `<!doctype html>
 <html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
 <meta name="color-scheme" content="light dark"><title>${esc(title)}</title><style>${CSS}</style></head>
-<body><header><b>VDS</b><a href="/">Flows</a><a href="/product-wide">Product-wide rules</a></header>${banner}
+<body><header><b>VDS</b><a href="/">Journeys</a><a href="/product-wide">Product-wide rules</a></header>${banner}
 <main>${body}</main></body></html>`;
 }
 function indexModel(model, evidence2 = []) {
@@ -7991,25 +7992,25 @@ function indexModel(model, evidence2 = []) {
     latest: latest(evidence2),
     rules,
     capabilityOf,
-    flowById: new Map(model.flows.map((f) => [f.id, f]))
+    journeyById: new Map(model.journeys.map((f) => [f.id, f]))
   };
 }
 function plainOf(rule) {
   return rule.plain ?? `${rule.statement} (not written as an EARS statement)`;
 }
-function stepCount(flow) {
-  return Object.values(flow.states).filter(isStep).length;
+function stepCount(journey) {
+  return Object.values(journey.states).filter(isStep).length;
 }
 function isTicked(state, m) {
   const rules = stateRules2(state).map((r) => m.rules.get(r));
   if (rules.length === 0 || rules.some((r) => !r || r.scenarios.length === 0)) return false;
   return rules.every((r) => r.scenarios.every((s) => m.latest[s.id]?.status === "passed"));
 }
-function walkedCount(flow, m) {
-  return Object.values(flow.states).filter((s) => isStep(s) && isTicked(s, m)).length;
+function walkedCount(journey, m) {
+  return Object.values(journey.states).filter((s) => isStep(s) && isTicked(s, m)).length;
 }
-function walkedText(flow, m) {
-  return `${walkedCount(flow, m)} of ${stepCount(flow)} steps walked`;
+function walkedText(journey, m) {
+  return `${walkedCount(journey, m)} of ${stepCount(journey)} steps walked`;
 }
 function runSummary(rule, m) {
   const ran = rule.scenarios.filter((s) => m.latest[s.id]);
@@ -8021,109 +8022,110 @@ function stateRules2(state) {
   const viaChoice = (state.choices ?? []).flatMap((c) => c.requirements ?? []);
   return [...state.requirements ?? [], ...viaChoice];
 }
-function walk(flow) {
+function walk(journey) {
   const order = [];
   const seen = /* @__PURE__ */ new Set();
   const visit2 = (id) => {
-    const state = flow.states[id];
+    const state = journey.states[id];
     if (!id || seen.has(id) || !state) return;
     seen.add(id);
     order.push(id);
     if (state.type === "choice") for (const c of state.choices ?? []) visit2(c.next);
     else visit2(state.next);
   };
-  visit2(flow.start_at);
+  visit2(journey.start_at);
   return order;
 }
-function ruleLink(rule, flowId) {
-  const query = flowId ? `?from=${encodeURIComponent(flowId)}` : "";
+function ruleLink(rule, journeyId) {
+  const query = journeyId ? `?from=${encodeURIComponent(journeyId)}` : "";
   return `<a href="/rules/${encodeURIComponent(rule.id)}${query}">${esc(plainOf(rule))}</a>`;
 }
-function flowCard(flow, m) {
-  return `<li><a href="/flows/${encodeURIComponent(flow.id)}"><b>${esc(flow.title)}</b></a>
-<div class="muted">${esc(flow.persona)} \xB7 v${esc(flow.version)} \xB7 ${walkedText(flow, m)}</div>${changedBadge(flow, m, TOOLS)}</li>`;
+function journeyCard(journey, m) {
+  return `<li><a href="/journeys/${encodeURIComponent(journey.id)}"><b>${esc(journey.title)}</b></a>
+<div class="muted"><code>${esc(journey.id)}</code> \xB7 ${esc(journey.persona)} \xB7 v${esc(journey.version)} \xB7 ${walkedText(journey, m)}</div>${changedBadge(journey, m, TOOLS)}</li>`;
 }
-function flowsByCapability(m) {
+function journeysByCapability(m) {
   const sections = m.capabilities.map((c) => {
     const mine = new Set(c.requirements.map((r) => r.id));
-    return { c, flows: m.flows.filter((f) => f.requirements.some((id) => mine.has(id))) };
-  }).filter((s) => s.flows.length);
-  const bare = m.flows.filter((f) => f.requirements.length === 0);
+    return { c, journeys: m.journeys.filter((f) => f.requirements.some((id) => mine.has(id))) };
+  }).filter((s) => s.journeys.length);
+  const bare = m.journeys.filter((f) => f.requirements.length === 0);
   const html = sections.map(
-    (s) => `<h2>${esc(s.c.title)}</h2><ul class="list">${s.flows.map((f) => flowCard(f, m)).join("")}</ul>`
+    (s) => `<h2>${esc(s.c.title)}</h2><ul class="list">${s.journeys.map((f) => journeyCard(f, m)).join("")}</ul>`
   );
   if (bare.length)
     html.push(
-      `<h2>No rules yet</h2><ul class="list">${bare.map((f) => flowCard(f, m)).join("")}</ul>`
+      `<h2>No rules yet</h2><ul class="list">${bare.map((f) => journeyCard(f, m)).join("")}</ul>`
     );
   return html.join("");
 }
-function emptyWorkspace() {
-  return `<h1>No flows yet</h1>
-<p class="sub">Connect an AI app to this studio, then ask it to write the first flow through MCP.</p>
+function emptyWorkspace(origin) {
+  const address = origin ? `${esc(origin)}/mcp` : "http://localhost:&lt;port&gt;/mcp";
+  return `<h1>No journeys yet</h1>
+<p class="sub">Connect an AI app to this studio, then ask it to write the first journey through MCP.</p>
 <div class="card"><h3>Connect an AI app</h3>
-<p>Add this MCP address to your AI app, which is this server's /mcp:</p>
-<pre>http://localhost:&lt;port&gt;/mcp</pre>
-<p class="muted">Use the port this server is listening on. Then ask the app to write the first flow: who it is for, the steps they take, and the rules on each step.</p></div>`;
+<p>Add this MCP address to your AI app:</p>
+<pre>${address}</pre>
+<p class="muted">Then ask the app to write the first journey: who it is for, the steps they take, and the rules on each step.</p></div>`;
 }
-function dashboard(m, query) {
-  if (m.flows.length === 0) return emptyWorkspace();
+function dashboard(m, query, origin) {
+  if (m.journeys.length === 0) return emptyWorkspace(origin);
   const grouped = query.get("group") === "capability";
-  const switcher = grouped ? '<a href="/">List all flows</a>' : '<a href="/?group=capability">Group by capability</a>';
-  const list = grouped ? flowsByCapability(m) : `<ul class="list">${m.flows.map((f) => flowCard(f, m)).join("")}</ul>`;
-  return `<h1>Flows</h1><p class="sub">${switcher} \xB7 <a href="/product-wide">Product-wide rules</a></p>${list}`;
+  const switcher = grouped ? '<a href="/">List all journeys</a>' : '<a href="/?group=capability">Group by capability</a>';
+  const list = grouped ? journeysByCapability(m) : `<ul class="list">${m.journeys.map((f) => journeyCard(f, m)).join("")}</ul>`;
+  return `<h1>Journeys</h1><p class="sub">${switcher} \xB7 <a href="/product-wide">Product-wide rules</a></p>${list}`;
 }
-function stopBox(id, flow, m) {
-  const stop = flow.states[id];
+function stopBox(id, journey, m) {
+  const stop = journey.states[id];
   const lines = (stop.requirements ?? []).map((r) => m.rules.get(r)).filter(Boolean).map(plainOf);
-  const back = stop.next && flow.states[stop.next] ? ` Back to ${flow.states[stop.next].title ?? stop.next}.` : "";
+  const back = stop.next && journey.states[stop.next] ? ` Back to ${journey.states[stop.next].title ?? stop.next}.` : "";
   return `<div class="stop"><b>${esc(stop.title ?? id)}</b><small>${esc(lines.join(" "))}${esc(back)}</small></div>`;
 }
-function choiceBox(state, flow, numbers) {
+function choiceBox(state, journey, numbers) {
   const lines = (state.choices ?? []).map((c) => {
-    const target = flow.states[c.next];
+    const target = journey.states[c.next];
     const n = numbers.get(c.next);
     return `${esc(c.when)} \u2192 ${esc(target?.title ?? c.next)}${n ? ` (${n})` : ""}`;
   });
   return `<div class="choice">${lines.join("<br>")}</div>`;
 }
-function stepRow(id, flow, m, numbers) {
-  const state = flow.states[id];
-  const href = `/flows/${encodeURIComponent(flow.id)}/steps/${encodeURIComponent(id)}`;
+function stepRow(id, journey, m, numbers) {
+  const state = journey.states[id];
+  const href = `/journeys/${encodeURIComponent(journey.id)}/steps/${encodeURIComponent(id)}`;
   const tick = isTicked(state, m) ? ' <span class="tick" title="Every scenario passed">\u2713</span>' : "";
   const left = `<a class="box ${esc(state.type)}" href="${href}"><b><span class="num">${numbers.get(id)}</span>${esc(state.title ?? id)}${tick}</b>${state.shows ? `<small>${esc(state.shows)}</small>` : ""}</a>`;
-  const stops = (state.catch ?? []).filter((s) => flow.states[s]).map((s) => stopBox(s, flow, m));
-  const notes = stateRules2(state).map((r) => m.rules.get(r)).filter(Boolean).map((r) => `<li>${ruleLink(r, flow.id)}</li>`);
+  const stops = stopBoxes(state, journey, m);
+  const notes = stateRules2(state).map((r) => m.rules.get(r)).filter(Boolean).map((r) => `<li>${ruleLink(r, journey.id)}</li>`);
   return `<div class="row"><div>${left}</div><div>${stops.join("")}<ul class="notes">${notes.join("")}</ul></div></div>`;
 }
-function flowBody(flow, m) {
-  const order = walk(flow);
+function journeyBody(journey, m) {
+  const order = walk(journey);
   const numbers = /* @__PURE__ */ new Map();
-  for (const id of order) if (isStep(flow.states[id])) numbers.set(id, numbers.size + 1);
-  const rows = order.filter((id) => flow.states[id].type !== "stop").map((id) => {
-    const state = flow.states[id];
-    if (isStep(state)) return stepRow(id, flow, m, numbers);
+  for (const id of order) if (isStep(journey.states[id])) numbers.set(id, numbers.size + 1);
+  const rows = order.filter((id) => journey.states[id].type !== "stop").map((id) => {
+    const state = journey.states[id];
+    if (isStep(state)) return stepRow(id, journey, m, numbers);
     if (state.type === "choice")
-      return `<div class="row"><div>${choiceBox(state, flow, numbers)}</div><div></div></div>`;
-    const flowOut = state.next_flow ? ` \xB7 next: <a href="/flows/${esc(state.next_flow)}">${esc(state.next_flow)}</a>` : "";
-    return `<div class="row"><div><span class="end">${esc(state.title ?? "Done")}${flowOut}</span></div><div></div></div>`;
+      return `<div class="row"><div>${choiceBox(state, journey, numbers)}</div><div></div></div>`;
+    const journeyOut = state.next_journey ? ` \xB7 next: <a href="/journeys/${esc(state.next_journey)}">${esc(state.next_journey)}</a>` : "";
+    return `<div class="row"><div><span class="end">${esc(state.title ?? "Done")}${journeyOut}</span></div><div></div></div>`;
   });
   const reached = new Set(order);
-  const loose = Object.keys(flow.states).filter(
-    (id) => flow.states[id].type === "stop" && !order.some((o) => (flow.states[o].catch ?? []).includes(id))
+  const loose = Object.keys(journey.states).filter(
+    (id) => journey.states[id].type === "stop" && !order.some((o) => (journey.states[o].catch ?? []).includes(id))
   );
-  const looseHtml = loose.length ? `<h2>Other places it can stop</h2>${loose.map((s) => stopBox(s, flow, m)).join("")}` : "";
-  const unreached = Object.keys(flow.states).filter(
-    (id) => isStep(flow.states[id]) && !reached.has(id)
+  const looseHtml = loose.length ? `<h2>Other places it can stop</h2>${loose.map((s) => stopBox(s, journey, m)).join("")}` : "";
+  const unreached = Object.keys(journey.states).filter(
+    (id) => isStep(journey.states[id]) && !reached.has(id)
   );
-  const unreachedHtml = unreached.length ? `<p class="muted">Not reached from the start: ${unreached.map((id) => esc(flow.states[id].title ?? id)).join(", ")}.</p>` : "";
-  const checklist = flow.requirements.map((id) => m.rules.get(id)).filter(Boolean).map(
-    (r) => `<li>${ruleLink(r, flow.id)} <span class="tag">${r.scenarios.length} ${r.scenarios.length === 1 ? "scenario" : "scenarios"} \xB7 ${runSummary(r, m)}</span></li>`
+  const unreachedHtml = unreached.length ? `<p class="muted">Not reached from the start: ${unreached.map((id) => esc(journey.states[id].title ?? id)).join(", ")}.</p>` : "";
+  const checklist = journey.requirements.map((id) => m.rules.get(id)).filter(Boolean).map(
+    (r) => `<li>${ruleLink(r, journey.id)} <span class="tag">${r.scenarios.length} ${r.scenarios.length === 1 ? "scenario" : "scenarios"} \xB7 ${runSummary(r, m)}</span></li>`
   );
-  return `<h1>${esc(flow.title)}</h1><p class="sub">${esc(flow.persona)} \xB7 v${esc(flow.version)} \xB7 ${walkedText(flow, m)}${compareLink(flow)}</p>${changedBadge(flow, m, TOOLS)}
+  return `<h1>${esc(journey.title)}</h1><p class="sub">${esc(journey.persona)} \xB7 v${esc(journey.version)} \xB7 ${walkedText(journey, m)}${compareLink(journey)}</p>${changedBadge(journey, m, TOOLS)}
 <div class="row"><h3>Steps</h3><h3>Where it can stop, and the rules</h3></div>
 ${rows.join('<div class="row"><div class="arrow">\u2193</div><div></div></div>')}${looseHtml}${unreachedHtml}
-<h2>Checklist</h2><ul class="list">${checklist.join("") || '<li class="muted">This flow has no rules yet.</li>'}</ul>`;
+<h2>Checklist</h2><ul class="list">${checklist.join("") || '<li class="muted">This journey has no rules yet.</li>'}</ul>`;
 }
 function scenarioRun(id, m) {
   const run = m.latest[id];
@@ -8135,54 +8137,57 @@ function scenarioList(rule, m) {
     (s) => `<li><b>${esc(s.id)}</b> ${esc(s.name)} <span class="tag">${scenarioRun(s.id, m)}</span></li>`
   ).join("")}</ul>`;
 }
-function ruleCard(rule, flowId, m) {
+function ruleCard(rule, journeyId, m) {
   return `<div class="card"><h3>${esc(rule.id)} \xB7 ${esc(rule.title)}</h3>
-<p>${esc(rule.statement)}</p><p class="muted">${ruleLink(rule, flowId)}</p>${scenarioList(rule, m)}</div>`;
+<p>${esc(rule.statement)}</p><p class="muted">${ruleLink(rule, journeyId)}</p>${scenarioList(rule, m)}</div>`;
 }
-function stepBody(flow, id, m) {
-  const state = flow.states[id];
+function stopBoxes(state, journey, m) {
+  return (state.catch ?? []).filter((s) => journey.states[s]).map((s) => stopBox(s, journey, m));
+}
+function stepBody(journey, id, m) {
+  const state = journey.states[id];
   const rules = stateRules2(state).map((r) => m.rules.get(r)).filter(Boolean);
-  const stops = (state.catch ?? []).filter((s) => flow.states[s]).map((s) => stopBox(s, flow, m));
-  return `<p class="sub"><a href="/flows/${encodeURIComponent(flow.id)}">${esc(flow.title)}</a></p>
+  const stops = stopBoxes(state, journey, m);
+  return `<p class="sub"><a href="/journeys/${encodeURIComponent(journey.id)}">${esc(journey.title)}</a></p>
 <h1>${esc(state.title ?? id)}</h1>${state.shows ? `<p class="sub">${esc(state.shows)}</p>` : ""}
 ${stops.length ? `<h2>Where it can stop</h2>${stops.join("")}` : ""}
-<h2>Rules</h2>${rules.map((r) => ruleCard(r, flow.id, m)).join("") || '<p class="muted">This step has no rules yet.</p>'}`;
+<h2>Rules</h2>${rules.map((r) => ruleCard(r, journey.id, m)).join("") || '<p class="muted">This step has no rules yet.</p>'}`;
 }
 function ruleBody(rule, m, from) {
-  const others = rule.used_by.filter((id) => id !== from).map((id) => m.flowById.get(id)).filter(Boolean);
-  const used = others.length ? `<ul class="list">${others.map((f) => `<li><a href="/flows/${encodeURIComponent(f.id)}">${esc(f.title)}</a> <span class="muted">${esc(f.persona)} \xB7 v${esc(f.version)}</span></li>`).join("")}</ul>` : `<p class="muted">${from ? "No other flow uses this rule." : "No flow uses this rule."}</p>`;
+  const others = rule.used_by.filter((id) => id !== from).map((id) => m.journeyById.get(id)).filter(Boolean);
+  const used = others.length ? `<ul class="list">${others.map((f) => `<li><a href="/journeys/${encodeURIComponent(f.id)}">${esc(f.title)}</a> <span class="muted">${esc(f.persona)} \xB7 v${esc(f.version)}</span></li>`).join("")}</ul>` : `<p class="muted">${from ? "No other journey uses this rule." : "No journey uses this rule."}</p>`;
   const where = rule.scope === "product" ? '<p class="tag">Product-wide rule</p>' : "";
-  return `<p class="sub">${from && m.flowById.has(from) ? `<a href="/flows/${encodeURIComponent(from)}">${esc(m.flowById.get(from).title)}</a>` : '<a href="/">Flows</a>'}</p>
+  return `<p class="sub">${from && m.journeyById.has(from) ? `<a href="/journeys/${encodeURIComponent(from)}">${esc(m.journeyById.get(from).title)}</a>` : '<a href="/">Journeys</a>'}</p>
 <h1>${esc(rule.id)} \xB7 ${esc(rule.title)}</h1>${where}
 <div class="card"><h3>Statement</h3><p>${esc(rule.statement)}</p><h3>In plain words</h3><p>${esc(plainOf(rule))}</p></div>
 <h2>Scenarios</h2>${scenarioList(rule, m)}
-<h2>${from ? "Other flows that use it" : "Flows that use it"}</h2>${used}`;
+<h2>${from ? "Other journeys that use it" : "Journeys that use it"}</h2>${used}`;
 }
 function productWide(m) {
   const sections = m.capabilities.map((c) => ({ c, rules: c.requirements.filter((r) => r.scope === "product") })).filter((s) => s.rules.length).map(
     (s) => `<h2>${esc(s.c.title)}</h2><ul class="list">${s.rules.map((r) => `<li>${ruleLink(r)}</li>`).join("")}</ul>`
   );
-  return `<h1>Product-wide rules</h1><p class="sub">Rules that hold across every flow.</p>${sections.join("") || '<p class="muted">No product-wide rules yet.</p>'}`;
+  return `<h1>Product-wide rules</h1><p class="sub">Rules that hold across every journey.</p>${sections.join("") || '<p class="muted">No product-wide rules yet.</p>'}`;
 }
-function flowRoute(m, [id, kind, state], query) {
-  const flow = m.flowById.get(id);
-  if (!flow) return void 0;
-  if (kind === "compare" && state === void 0) return compareRoute(flow, m, query, TOOLS);
-  if (kind === void 0) return { title: flow.title, body: flowBody(flow, m) };
-  if (kind !== "steps" || !isStep(flow.states[state])) return void 0;
-  return { title: flow.states[state].title ?? state, body: stepBody(flow, state, m) };
+function journeyRoute(m, [id, kind, state], query) {
+  const journey = m.journeyById.get(id);
+  if (!journey) return void 0;
+  if (kind === "compare" && state === void 0) return compareRoute(journey, m, query, TOOLS);
+  if (kind === void 0) return { title: journey.title, body: journeyBody(journey, m) };
+  if (kind !== "steps" || !isStep(journey.states[state])) return void 0;
+  return { title: journey.states[state].title ?? state, body: stepBody(journey, state, m) };
 }
 function ruleRoute(m, [id], query) {
   const rule = m.rules.get(id);
   return rule && { title: rule.title, body: ruleBody(rule, m, query.get("from")) };
 }
-function route(m, parts, query) {
-  if (parts.length === 0) return { title: "Flows", body: dashboard(m, query) };
+function route(m, parts, query, origin) {
+  if (parts.length === 0) return { title: "Journeys", body: dashboard(m, query, origin) };
   if (!Object.hasOwn(ROUTES, parts[0])) return void 0;
   return ROUTES[parts[0]](m, parts.slice(1), query);
 }
 function notFound(findings) {
-  const body = '<h1>Not found</h1><p class="sub">There is no such page. <a href="/">Back to the flows</a>.</p>';
+  const body = '<h1>Not found</h1><p class="sub">There is no such page. <a href="/">Back to the journeys</a>.</p>';
   return { status: 404, html: layout("Not found", body, findings) };
 }
 function renderPage(mapper, pathname, files, findings, evidence2 = []) {
@@ -8199,7 +8204,13 @@ function renderPage(mapper, pathname, files, findings, evidence2 = []) {
       )
     };
   const parts = url2.pathname.split("/").filter(Boolean).map(decodeURIComponent);
-  const found = route(versionModel(indexModel(model, evidence2), files), parts, url2.searchParams);
+  const origin = url2.origin === "http://studio" ? void 0 : url2.origin;
+  const found = route(
+    versionModel(indexModel(model, evidence2), files),
+    parts,
+    url2.searchParams,
+    origin
+  );
   if (!found) return notFound(shown);
   return { status: 200, html: layout(found.title, found.body, shown) };
 }
@@ -8208,7 +8219,7 @@ var init_pages = __esm({
   "src/studio/pages.js"() {
     init_evidence();
     init_versionPages();
-    STEP_TYPES = ["screen", "outside", "subflow"];
+    STEP_TYPES = ["screen", "outside", "subjourney"];
     CSS = `
 :root{--bg:#fff;--fg:#1b1b1f;--muted:#5f6368;--line:#d9dbe0;--card:#f6f7f9;--accent:#2f5bd8;--stop:#b3261e;--stopbg:#fdf0ef;--warn:#8a5a00;--warnbg:#fff6e0;--ok:#1e7b34}
 @media (prefers-color-scheme: dark){:root{--bg:#16171a;--fg:#e8e9ed;--muted:#9aa0a8;--line:#34363c;--card:#1f2125;--accent:#8ab0ff;--stop:#ff9a92;--stopbg:#2b1b1a;--warn:#f0c36a;--warnbg:#2a2415;--ok:#6fcf86}}
@@ -8243,7 +8254,7 @@ pre{background:var(--card);border:1px solid var(--line);border-radius:8px;paddin
     ESCAPES = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" };
     TOOLS = { esc, plainOf };
     ROUTES = {
-      flows: (m, rest, query) => [1, 2, 3].includes(rest.length) ? flowRoute(m, rest, query) : void 0,
+      journeys: (m, rest, query) => [1, 2, 3].includes(rest.length) ? journeyRoute(m, rest, query) : void 0,
       rules: (m, rest, query) => rest.length === 1 ? ruleRoute(m, rest, query) : void 0,
       "product-wide": (m, rest) => rest.length === 0 ? { title: "Product-wide rules", body: productWide(m) } : void 0
     };
@@ -24211,8 +24222,8 @@ function finalize(ctx, schema) {
         compactTypeUnion(entry[1].def ?? entry[1].schema);
       }
     }
-    for (const rewrite of ctx.deferred)
-      rewrite();
+    for (const rewrite2 of ctx.deferred)
+      rewrite2();
     if (ctx.intersections.length) {
       const carriers = /* @__PURE__ */ new Map();
       for (const seen of ctx.seen.values()) {
@@ -44271,13 +44282,13 @@ var mcp_exports = {};
 __export(mcp_exports, {
   mcpHandler: () => mcpHandler
 });
-import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync8, rmSync, writeFileSync as writeFileSync5 } from "node:fs";
-import { dirname as dirname3, join as join7 } from "node:path";
+import { existsSync as existsSync5, mkdirSync as mkdirSync5, readFileSync as readFileSync9, rmSync, writeFileSync as writeFileSync6 } from "node:fs";
+import { dirname as dirname3, join as join8 } from "node:path";
 import { Readable } from "node:stream";
 function specPath(path) {
   const [dir, name, ...rest] = path.split("/");
   const ok = FOLDERS2.includes(dir) && name && rest.length === 0 && !path.includes("..") && !path.includes("\\") && name.endsWith(EXTENSION[dir]);
-  return ok ? null : `"${path}" is not a spec file. Use capabilities/<NAME>.yaml, flows/<name>.yaml or scenarios/<ID>.feature.`;
+  return ok ? null : `"${path}" is not a spec file. Use capabilities/<NAME>.yaml, journeys/<name>.yaml or scenarios/<ID>.feature.`;
 }
 function check2(mapper, files) {
   const findings = mapper.v2Check(files);
@@ -44298,8 +44309,8 @@ function impactLines(effect) {
   const moved = effect.affected.map((id) => `${id} (now version ${effect.moved[id]}, not built)`);
   return `
 Rule changed: ${effect.rules.join(", ")}.
-Affected flows: ${moved.join(", ") || "none"}.
-Not affected flows: ${effect.unaffected.join(", ") || "none"}.`;
+Affected journeys: ${moved.join(", ") || "none"}.
+Not affected journeys: ${effect.unaffected.join(", ") || "none"}.`;
 }
 function buildServer(root, mapper) {
   const server = new McpServer(
@@ -44310,7 +44321,7 @@ function buildServer(root, mapper) {
   server.registerTool(
     "vds_index",
     {
-      description: "The workspace index: every capability, rule, flow and scenario with its id. Call this first.",
+      description: "The workspace index: every capability, rule, journey and scenario with its id. Call this first.",
       inputSchema: external_exports.object({}),
       annotations: { readOnlyHint: true }
     },
@@ -44319,19 +44330,19 @@ function buildServer(root, mapper) {
   server.registerTool(
     "vds_guide",
     {
-      description: "The text of VDS.md: how rules, flows and scenarios are written in this workspace.",
+      description: "The text of VDS.md: how rules, journeys and scenarios are written in this workspace.",
       inputSchema: external_exports.object({}),
       annotations: { readOnlyHint: true }
     },
     async () => {
-      const file2 = join7(root, "VDS.md");
-      return existsSync4(file2) ? say(readFileSync8(file2, "utf8")) : refuse("This workspace has no VDS.md.");
+      const file2 = join8(root, "VDS.md");
+      return existsSync5(file2) ? say(readFileSync9(file2, "utf8")) : refuse("This workspace has no VDS.md.");
     }
   );
   server.registerTool(
     "vds_read",
     {
-      description: "Read one spec file: capabilities/<NAME>.yaml, flows/<name>.yaml or scenarios/<ID>.feature.",
+      description: "Read one spec file: capabilities/<NAME>.yaml, journeys/<name>.yaml or scenarios/<ID>.feature.",
       inputSchema: external_exports.object({ path: pathArg }),
       annotations: { readOnlyHint: true }
     },
@@ -44393,22 +44404,22 @@ function buildServer(root, mapper) {
       delete after[path];
       const refused = newProblems(mapper, before, after);
       if (refused) return refused;
-      rmSync(join7(root, path));
+      rmSync(join8(root, path));
       return say(`Deleted ${path}.`);
     }
   );
   server.registerTool(
     "vds_mark_built",
     {
-      description: 'Mark a flow built at its current version, recording who and when. Use the flow id, like "onboarding".',
-      inputSchema: external_exports.object({ flow: external_exports.string().describe("The flow id.") }),
+      description: 'Mark a journey built at its current version, recording who and when. Use the journey id, like "onboarding".',
+      inputSchema: external_exports.object({ journey: external_exports.string().describe("The journey id.") }),
       annotations: { destructiveHint: true }
     },
-    async ({ flow }) => {
-      const writes = builtWrites(readWorkspace(root), flow);
-      if (!writes) return refuse(`No flow ${flow}.`);
+    async ({ journey }) => {
+      const writes = builtWrites(readWorkspace(root), journey);
+      if (!writes) return refuse(`No journey ${journey}.`);
       writeAll(root, writes);
-      return say(`${flow} is built at its current version.`);
+      return say(`${journey} is built at its current version.`);
     }
   );
   return server;
@@ -44454,8 +44465,8 @@ var init_mcp = __esm({
     init_built();
     init_versions();
     init_workspace();
-    EXTENSION = { capabilities: ".yaml", flows: ".yaml", scenarios: ".feature" };
-    INSTRUCTIONS = "VDS workspace on this machine. Call vds_index first to see every rule, flow and scenario, and vds_guide for how to write them. Change files with vds_write and vds_delete: the checker runs on the whole result and refuses a change that adds a problem, naming each one. Fix what it names and write again.";
+    EXTENSION = { capabilities: ".yaml", journeys: ".yaml", scenarios: ".feature" };
+    INSTRUCTIONS = "VDS workspace on this machine. Call vds_index first to see every rule, journey and scenario, and vds_guide for how to write them. Change files with vds_write and vds_delete: the checker runs on the whole result and refuses a change that adds a problem, naming each one. Fix what it names and write again.";
     say = (text) => ({ content: [{ type: "text", text }] });
     refuse = (text) => ({ isError: true, content: [{ type: "text", text }] });
     findingKey = (f) => `${f.path}
@@ -44468,7 +44479,7 @@ ${f.message}`;
 init_node();
 init_built();
 import { spawn } from "node:child_process";
-import { existsSync as existsSync5, readFileSync as readFileSync9 } from "node:fs";
+import { existsSync as existsSync6, readFileSync as readFileSync10 } from "node:fs";
 import { resolve } from "node:path";
 
 // src/changelog.js
@@ -44476,7 +44487,7 @@ import { existsSync, readFileSync as readFileSync3 } from "node:fs";
 
 // src/version.js
 import { readFileSync as readFileSync2 } from "node:fs";
-var baked = false ? null : "0.0.7";
+var baked = false ? null : "0.0.8";
 var VERSION = process.env.VDS_VERSION ?? baked ?? JSON.parse(readFileSync2(new URL("../package.json", import.meta.url), "utf8")).version;
 function compare(a, b) {
   const [x, y] = [a, b].map((v) => v.split("-")[0].split(".").map(Number));
@@ -44536,21 +44547,21 @@ import { join as join3 } from "node:path";
 // src/guide.js
 var GUIDE = `# Working in this VDS workspace
 
-This folder holds the product's requirements, flows and scenarios as plain files.
+This folder holds the product's requirements, journeys and scenarios as plain files.
 Read and write them with the vds command.
 
 ## Layout
 
 - capabilities/<CODE>.yaml: one capability and its requirements (ids like ONB-01).
-- flows/<id>.yaml: a journey made of states; each state points at requirement ids.
+- journeys/<id>.yaml: a journey made of states; each state points at requirement ids.
 - scenarios/<REQ-ID>.feature: Given, When, Then scenarios for one requirement.
 
 ## How to work
 
-1. Run \`vds index\` first. It prints one line per flow and requirement, so you know what exists.
+1. Run \`vds index\` first. It prints one line per journey and requirement, so you know what exists.
 2. Open one file at a time. Read only the file you are changing.
 3. Write requirements in EARS: "When <trigger>, the system SHALL <response>." The system is always the subject.
-4. Point flows at requirement ids. A state lists the ids it needs under \`requirements:\`.
+4. Point journeys at requirement ids. A state lists the ids it needs under \`requirements:\`.
 5. Run \`vds check\` before you finish. It prints "valid" when nothing is wrong; fix every problem it lists.
 `;
 var markerFor = (version2) => `<!-- vds ${version2} -->`;
@@ -44560,8 +44571,8 @@ ${GUIDE}`;
 }
 
 // src/init.js
-var FOLDERS = ["capabilities", "flows", "scenarios"];
-var FIRST_PORT = 4600;
+var FOLDERS = ["capabilities", "journeys", "scenarios"];
+var FIRST_PORT = Number(process.env.VDS_FIRST_PORT) || 4600;
 async function freePort() {
   for (let port = FIRST_PORT; ; port++) {
     const free = await new Promise((resolve2) => {
@@ -44589,12 +44600,75 @@ async function init(root) {
 
 // src/update.js
 import { spawnSync } from "node:child_process";
-import { existsSync as existsSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "node:fs";
-import { dirname as dirname2, join as join4 } from "node:path";
+import { existsSync as existsSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "node:fs";
+import { dirname as dirname2, join as join5 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // src/migrations.js
-var MIGRATIONS = [];
+import {
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync4,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync5,
+  rmdirSync,
+  writeFileSync as writeFileSync4,
+  renameSync
+} from "node:fs";
+import { join as join4 } from "node:path";
+function journeyText(text) {
+  const hasKind = /^kind:/m.test(text);
+  return text.split("\n").map((line) => {
+    const top = line.match(/^flow:(.*)$/);
+    if (top) return hasKind ? `journey:${top[1]}` : `journey:${top[1]}
+kind: journey`;
+    return line.replace(/\bnext_flow(?=\s*:)/g, "next_journey").replace(/(\btype:\s*)subflow\b/g, "$1subjourney");
+  }).join("\n");
+}
+function rewrite(file2) {
+  const before = readFileSync5(file2, "utf8");
+  const after = journeyText(before);
+  if (after === before) return false;
+  writeFileSync4(file2, after);
+  return true;
+}
+var yamlFiles = (dir) => existsSync3(dir) ? readdirSync2(dir).filter((n) => n.endsWith(".yaml")) : [];
+function flowsToJourneys(root) {
+  const changed = [];
+  const old = join4(root, "flows");
+  const target = join4(root, "journeys");
+  const names = yamlFiles(old);
+  if (names.length > 0) mkdirSync4(target, { recursive: true });
+  for (const name of names) {
+    if (existsSync3(join4(target, name)))
+      throw new Error(`journeys/${name} already exists; flows/${name} was left in place`);
+    renameSync(join4(old, name), join4(target, name));
+    rewrite(join4(target, name));
+    changed.push(`flows/${name} -> journeys/${name}`);
+  }
+  if (existsSync3(old) && readdirSync2(old).length === 0) rmdirSync(old);
+  for (const name of yamlFiles(target)) {
+    if (!changed.some((c) => c.endsWith(`journeys/${name}`)) && rewrite(join4(target, name)))
+      changed.push(`journeys/${name}`);
+  }
+  return changed;
+}
+function rewriteVersions(root) {
+  const versions = join4(root, "versions");
+  const changed = [];
+  for (const id of existsSync3(versions) ? readdirSync2(versions) : []) {
+    for (const name of yamlFiles(join4(versions, id))) {
+      if (rewrite(join4(versions, id, name))) changed.push(`versions/${id}/${name}`);
+    }
+  }
+  return changed;
+}
+var MIGRATIONS = [
+  {
+    version: "0.0.8",
+    describe: "flows became journeys: flows/ moves to journeys/, with kind: journey",
+    run: (root) => [...flowsToJourneys(root), ...rewriteVersions(root)]
+  }
+];
 async function loadMigrations() {
   if (!process.env.VDS_MIGRATIONS) return MIGRATIONS;
   return (await import(process.env.VDS_MIGRATIONS)).default;
@@ -44626,28 +44700,28 @@ function installKind() {
   if (file2.includes("/_npx/")) return { kind: "npx" };
   const at = file2.indexOf("/node_modules/");
   const root = at > 0 ? file2.slice(0, at) : null;
-  if (root && existsSync3(join4(root, "package.json"))) return { kind: "project", root };
+  if (root && existsSync4(join5(root, "package.json"))) return { kind: "project", root };
   return { kind: "global" };
 }
 function installPlan(version2) {
   const spec = `@teurons/vds@${version2}`;
   const found = installKind();
   if (found.kind === "project") {
-    const has = (f) => existsSync3(join4(found.root, f));
+    const has = (f) => existsSync4(join5(found.root, f));
     const cmd = has("pnpm-lock.yaml") ? `pnpm add -D ${spec}` : has("yarn.lock") ? `yarn add -D ${spec}` : `npm install -D ${spec}`;
-    return { ...found, cmd, bin: join4(found.root, "node_modules", ".bin", "vds") };
+    return { ...found, cmd, bin: join5(found.root, "node_modules", ".bin", "vds") };
   }
   return { ...found, cmd: `npm install -g ${spec}`, bin: "vds" };
 }
 function refreshGuide(folder) {
-  const path = join4(folder, "VDS.md");
-  if (!existsSync3(path)) return false;
-  const current = readFileSync5(path, "utf8");
+  const path = join5(folder, "VDS.md");
+  if (!existsSync4(path)) return false;
+  const current = readFileSync6(path, "utf8");
   const marked = current.match(MARKER)?.[1];
   if (marked && compare(marked, VERSION) >= 0) return false;
   const next = guideText();
   if (next === current) return false;
-  writeFileSync4(path, next);
+  writeFileSync5(path, next);
   return true;
 }
 function runShell(cmd, version2, cwd) {
@@ -44659,8 +44733,8 @@ function runShell(cmd, version2, cwd) {
   });
 }
 function guideVersion(folder) {
-  const path = join4(folder, "VDS.md");
-  return existsSync3(path) ? readFileSync5(path, "utf8").match(MARKER)?.[1] : void 0;
+  const path = join5(folder, "VDS.md");
+  return existsSync4(path) ? readFileSync6(path, "utf8").match(MARKER)?.[1] : void 0;
 }
 async function afterUpdate(folder, old) {
   if (old) {
@@ -44715,8 +44789,8 @@ async function update(folder, { guideOnly = false, after } = {}) {
 // src/bin.js
 init_workspace();
 function defaultFolder() {
-  const isWorkspace = [...FOLDERS2, "VDS.md"].some((name) => existsSync5(name));
-  return !isWorkspace && existsSync5("vds-workspace") ? "vds-workspace" : ".";
+  const isWorkspace = [...FOLDERS2, "VDS.md"].some((name) => existsSync6(name));
+  return !isWorkspace && existsSync6("vds-workspace") ? "vds-workspace" : ".";
 }
 function openBrowser(url2) {
   if (process.env.VDS_NO_OPEN === "1") return;
@@ -44758,7 +44832,7 @@ function evidence(args) {
   const [report, folder] = args.filter((_, i) => at < 0 || i !== at && i !== at + 1);
   if (!report) throw new Error("usage: vds evidence <report-file> [folder] [--env <name>]");
   const root = resolve(folder ?? defaultFolder());
-  const r = recordEvidence({ reportText: readFileSync9(resolve(report), "utf8"), root, env });
+  const r = recordEvidence({ reportText: readFileSync10(resolve(report), "utf8"), root, env });
   const s = (n, one, many) => `${n} ${n === 1 ? one : many}`;
   console.log(
     `${s(r.recorded, "scenario", "scenarios")} recorded in ${r.file}; ${s(r.unmatched, "test", "tests")} matched no scenario`
@@ -44771,15 +44845,15 @@ async function printIndex(folder) {
   process.stdout.write(mapper.v2Index(readWorkspace(resolve(folder))));
   return 0;
 }
-function markFlowBuilt(flowId, folder) {
+function markJourneyBuilt(journeyId, folder) {
   const root = resolve(folder);
-  const writes = flowId && builtWrites(readWorkspace(root), flowId);
+  const writes = journeyId && builtWrites(readWorkspace(root), journeyId);
   if (!writes) {
-    console.error(`No flow ${flowId ?? ""}. Usage: vds built <flow-id> [folder]`);
+    console.error(`No journey ${journeyId ?? ""}. Usage: vds built <journey-id> [folder]`);
     return 1;
   }
   writeAll(root, writes);
-  console.log(`${flowId} is built at its current version.`);
+  console.log(`${journeyId} is built at its current version.`);
   return 0;
 }
 function changelog(args) {
@@ -44794,7 +44868,7 @@ var BY_FOLDER = { check: check3, index: printIndex };
 var BY_ARGS = {
   evidence,
   changelog,
-  built: ([flow, folder]) => markFlowBuilt(flow, folder ?? defaultFolder())
+  built: ([journey, folder]) => markJourneyBuilt(journey, folder ?? defaultFolder())
 };
 function updateFlags(argv) {
   const afterAt = argv.indexOf("--after");
@@ -44816,7 +44890,7 @@ async function main(argv) {
   if (Object.hasOwn(BY_FOLDER, command)) return BY_FOLDER[command](folder);
   if (Object.hasOwn(BY_ARGS, command)) return BY_ARGS[command](rest);
   console.error(
-    "usage: vds init [folder] | vds check [folder] | vds index [folder] | vds built <flow> [folder] | vds changelog [--since x.y.z] | vds update [folder] | vds run local [folder]"
+    "usage: vds init [folder] | vds check [folder] | vds index [folder] | vds built <journey> [folder] | vds changelog [--since x.y.z] | vds update [folder] | vds run local [folder]"
   );
   return 2;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teurons/vds",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "description": "The vds command: check, index and run a VDS workspace on your machine.",
   "type": "module",
   "bin": {