@wanbicoi/next-steps 0.1.0 → 0.1.1

package/dist/cli.js

@@ -2,7 +2,8 @@
 // @bun
 
 // src/cli.ts
-import { join as join4 } from "path";
+import { existsSync as existsSync3 } from "fs";
+import { basename, join as join2 } from "path";
 import { pathToFileURL } from "url";
 import { parseArgs } from "util";
 
@@ -29,16 +30,13 @@ function table(headers, rows) {
   return [render(headers), ...rows.map(render)].join(`
 `);
 }
-function formatScope(scope) {
-  return scope.length > 0 ? scope.join(" > ") : "-";
-}
 function formatTime(iso) {
   return iso.slice(0, 19).replace("T", " ");
 }
 function optionLine(option, index) {
-  const label = option.edge ? `${option.edge} -> ${option.node}` : option.node;
   const title = option.node === END ? "" : option.title;
-  const head = `  ${index + 1}. ${label}${title ? `  ${title}` : ""}`.trimEnd();
+  const review = option.reviewRequired ? "  [review]" : "";
+  const head = `  ${index + 1}. ${option.node}${title ? `  ${title}` : ""}${review}`.trimEnd();
   const lines = [head, `     ${option.description}`];
   if (option.condition)
     lines.push(`     when: ${option.condition}`);
@@ -57,14 +55,12 @@ function formatNext(next) {
 `);
 }
 function formatCurrent(next) {
-  if (next.done) {
-    return `current: ${next.current ?? END}  (finished)   scope: ${formatScope(next.scope)}`;
-  }
-  if (next.current === null) {
-    return `current: (not started)   scope: ${formatScope(next.scope)}`;
-  }
+  if (next.done)
+    return `current: ${next.current ?? END}  (finished)`;
+  if (next.current === null)
+    return "current: (not started)";
   const title = next.currentTitle ? `  (${next.currentTitle})` : "";
-  return `current: ${next.current}${title}   scope: ${formatScope(next.scope)}`;
+  return `current: ${next.current}${title}`;
 }
 
 // src/commands/shared.ts
@@ -83,8 +79,7 @@ function toJson(value) {
 
 // src/commands/session.ts
 function cmdCreate(service, input) {
-  const workflowId = requireString(input.workflowId, "workflow");
-  const { session, workflowTitle, next } = service.create({ workflowId, key: input.key });
+  const { session, workflowTitle, next } = service.create({ key: input.key });
   if (input.json) {
     return toJson({
       key: session.key,
@@ -92,7 +87,6 @@ function cmdCreate(service, input) {
       workflowTitle,
       status: session.status,
       current: null,
-      scope: next.scope,
       done: next.done,
       next: next.next,
       statePath: service.statePath
@@ -120,10 +114,10 @@ function cmdLog(service, input) {
       statePath: service.statePath
     });
   }
-  const origin = step.from ? `  (from ${step.from}${step.edge ? ` via ${step.edge}` : ""})` : "  (entry)";
+  const origin = step.from ? `  (from ${step.from})` : "  (entry)";
   return [
     `logged: #${step.seq} ${step.node}${origin}`,
-    `scope: ${formatScope(step.scope)}   status: ${session.status}`,
+    `status: ${session.status}`,
     "",
     formatNext(next)
   ].join(`
@@ -138,7 +132,6 @@ function cmdNext(service, input) {
       workflowId: session.workflowId,
       status: session.status,
       current: next.current === null ? null : { node: next.current, title: next.currentTitle, at: session.updatedAt },
-      scope: next.scope,
       done: next.done,
       next: next.next,
       statePath: service.statePath
@@ -156,31 +149,28 @@ function cmdSteps(service, input) {
       workflowId: session.workflowId,
       status: session.status,
       current: session.current,
-      scope: session.stack.map((frame) => frame.workflowId),
       steps,
       statePath: service.statePath
     });
   }
-  const head = [
-    `session: ${key}   status: ${session.status}   current: ${session.current ?? "(not started)"}`,
-    `scope: ${formatScope(session.stack.map((frame) => frame.workflowId))}`,
-    ""
-  ].join(`
-`);
+  const head = `session: ${key}   status: ${session.status}   current: ${session.current ?? "(not started)"}`;
   if (steps.length === 0)
-    return `${head}no steps yet`;
+    return `${head}
+
+no steps yet`;
   const rows = steps.map((step) => [
     String(step.seq),
     step.node,
     step.edge ?? "-",
     step.from ?? "-",
-    formatScope(step.scope),
     formatTime(step.at)
   ]);
-  return head + table(["SEQ", "NODE", "EDGE", "FROM", "SCOPE", "AT"], rows);
+  return `${head}
+
+${table(["SEQ", "NODE", "EDGE", "FROM", "AT"], rows)}`;
 }
 function cmdKeys(service, input) {
-  const sessions = service.keys(input.workflowId);
+  const sessions = service.keys();
   if (input.json) {
     return toJson({ statePath: service.statePath, sessions });
   }
@@ -242,19 +232,15 @@ function findTemplate() {
   }
   throw new AppError("viz_template_missing", "could not find viz/template.html next to the package", 3);
 }
-function renderVizHtml(template, workflows) {
-  const order = Object.keys(workflows).sort();
-  const data = JSON.stringify({ workflows, order }).replaceAll("<", "\\u003c");
+function renderVizHtml(template, workflow) {
+  const data = JSON.stringify({ workflow }).replaceAll("<", "\\u003c");
   return template.replace("__WORKFLOW_DATA__", data);
 }
-function startVizServer(registry, port) {
+function startVizServer(workflow, port) {
   const template = readFileSync(findTemplate(), "utf8");
   const cytoscapeJs = readFileSync(require2.resolve("cytoscape/dist/cytoscape.min.js"), "utf8");
   const dagreJs = readFileSync(require2.resolve("cytoscape-dagre"), "utf8");
-  const workflows = {};
-  for (const workflow of registry.values())
-    workflows[workflow.id] = workflow;
-  const html = renderVizHtml(template, workflows);
+  const html = renderVizHtml(template, workflow);
   const server = createServer((request, response) => {
     const path = (request.url ?? "/").split("?")[0];
     if (path === "/" || path === "/index.html") {
@@ -280,42 +266,143 @@ function startVizServer(registry, port) {
     process.exitCode = 1;
   });
   server.listen(port, "127.0.0.1");
-  return { url: `http://127.0.0.1:${port}`, workflows: Object.keys(workflows).sort() };
+  return { url: `http://127.0.0.1:${port}`, workflow: workflow.id };
 }
 
 // src/commands/workflow.ts
 import { existsSync as existsSync2, mkdirSync, writeFileSync } from "node:fs";
-import { join as join2 } from "node:path";
+import { dirname as dirname2 } from "node:path";
+var ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+function skeleton(id) {
+  return {
+    id,
+    title: id,
+    start: "start",
+    nodes: [
+      {
+        id: "start",
+        title: "Start",
+        description: "Describe the first step.",
+        next: [{ to: END, description: "Done." }]
+      }
+    ]
+  };
+}
+function cmdWorkflowNew(graphPath, id, json) {
+  if (existsSync2(graphPath)) {
+    throw usageError(`workflow file already exists: ${graphPath}`);
+  }
+  const workflowId = ID_PATTERN.test(id) ? id : "workflow";
+  mkdirSync(dirname2(graphPath), { recursive: true });
+  writeFileSync(graphPath, `${JSON.stringify(skeleton(workflowId), null, 2)}
+`, "utf8");
+  if (json)
+    return toJson({ created: graphPath, workflowId });
+  return `created: ${graphPath}`;
+}
+function requireValid(load) {
+  if (load.errors.length > 0 || !load.workflow) {
+    throw new AppError("invalid_workflow", `workflow file is invalid: ${load.path}`, 5, {
+      errors: load.errors
+    });
+  }
+  return load.workflow;
+}
+function cmdWorkflowShow(load, json) {
+  const wf = requireValid(load);
+  if (json)
+    return toJson({ workflow: wf, warnings: load.warnings });
+  const lines = [`${wf.id}  ${wf.title}`, `start: ${wf.start}`];
+  let group;
+  for (const node of wf.nodes) {
+    if (node.group !== group) {
+      group = node.group;
+      if (group)
+        lines.push("", group);
+    }
+    const review = node.reviewRequired ? "  [review]" : "";
+    lines.push(`  ${node.id}  ${node.title}${review}`);
+    for (const move of node.next) {
+      const when = move.condition ? `  [when: ${move.condition}]` : "";
+      lines.push(`    -> ${move.to}  ${move.description}${when}`);
+    }
+  }
+  return lines.join(`
+`);
+}
+function cmdWorkflowCheck(load, json) {
+  if (load.errors.length > 0 || !load.workflow) {
+    throw new AppError("invalid_workflow", "workflow validation failed", 5, {
+      errors: load.errors
+    });
+  }
+  const wf = load.workflow;
+  const moves = wf.nodes.reduce((count, node) => count + node.next.length, 0);
+  if (json) {
+    return toJson({
+      ok: true,
+      workflowId: wf.id,
+      title: wf.title,
+      nodes: wf.nodes.length,
+      moves,
+      warnings: load.warnings
+    });
+  }
+  const lines = [`ok: ${wf.id}  (${wf.nodes.length} nodes, ${moves} moves)`];
+  for (const warning of load.warnings)
+    lines.push(`warning: ${warning}`);
+  return lines.join(`
+`);
+}
 
 // src/workflow/validate.ts
 import { z } from "zod";
-var nodeSchema = z.object({
-  id: z.string().min(1),
-  type: z.enum(["node", "subgraph"]),
-  title: z.string().min(1),
+var moveSchema = z.object({
+  to: z.string().min(1),
   description: z.string(),
-  workflow: z.string().min(1).optional()
+  condition: z.string().min(1).optional()
 }).strict();
-var edgeSchema = z.object({
+var nodeSchema = z.object({
   id: z.string().min(1),
-  from: z.string().min(1),
-  to: z.string().min(1),
+  title: z.string().min(1),
   description: z.string(),
-  condition: z.string().min(1).optional()
+  group: z.string().min(1).optional(),
+  reviewRequired: z.boolean().optional(),
+  next: z.array(moveSchema).min(1)
 }).strict();
 var workflowSchema = z.object({
   id: z.string().min(1),
   title: z.string().min(1),
   start: z.string().min(1),
-  nodes: z.array(nodeSchema).min(1),
-  edges: z.array(edgeSchema)
+  nodes: z.array(nodeSchema).min(1)
 }).strict();
+function reportLegacyShape(raw, report) {
+  if (typeof raw !== "object" || raw === null)
+    return;
+  const file = raw;
+  if (Array.isArray(file.edges)) {
+    report(`edges are inline now: move each edge into its node's "next" list`);
+  }
+  if (!Array.isArray(file.nodes))
+    return;
+  for (const node of file.nodes) {
+    if (typeof node !== "object" || node === null)
+      continue;
+    const candidate = node;
+    if (candidate.type === "subgraph") {
+      report(`node "${String(candidate.id)}" is a subgraph: inline its nodes and use "group" for the label`);
+    } else if ("type" in candidate) {
+      report(`node "${String(candidate.id)}" has a "type" field; nodes are flat, drop it`);
+    }
+  }
+}
 function validateWorkflow(raw, source) {
   const errors = [];
   const warnings = [];
   const report = (message) => {
     errors.push(`${source}: ${message}`);
   };
+  reportLegacyShape(raw, report);
   const parsed = workflowSchema.safeParse(raw);
   if (!parsed.success) {
     for (const issue of parsed.error.issues) {
@@ -328,66 +415,46 @@ function validateWorkflow(raw, source) {
   const nodes = new Map;
   for (const node of wf.nodes) {
     if (node.id === END) {
-      report(`node id "${END}" is reserved; point an edge at END instead`);
+      report(`node id "${END}" is reserved; point a move at END instead`);
     }
     if (nodes.has(node.id)) {
       report(`duplicate node id "${node.id}"`);
     }
     nodes.set(node.id, node);
-    if (node.type === "subgraph") {
-      if (!node.workflow) {
-        report(`subgraph node "${node.id}" needs a "workflow" field`);
-      } else if (node.workflow === wf.id) {
-        report(`subgraph node "${node.id}" references its own workflow "${wf.id}"`);
-      }
-    } else if (node.workflow) {
-      report(`node "${node.id}" is not a subgraph but has a "workflow" field`);
-    }
   }
   if (wf.start === END) {
     report(`start must be a node, not END`);
   } else if (!nodes.has(wf.start)) {
     report(`start "${wf.start}" is not a node`);
   }
-  const edgeIds = new Set;
-  const pairs = new Set;
-  for (const edge of wf.edges) {
-    if (edgeIds.has(edge.id)) {
-      report(`duplicate edge id "${edge.id}"`);
-    }
-    edgeIds.add(edge.id);
-    const pair = `${edge.from} -> ${edge.to}`;
-    if (pairs.has(pair)) {
-      report(`duplicate edge ${pair}; transitions must be unambiguous`);
-    }
-    pairs.add(pair);
-    if (!nodes.has(edge.from)) {
-      report(`edge "${edge.id}" starts at unknown node "${edge.from}"`);
-    }
-    if (edge.to !== END && !nodes.has(edge.to)) {
-      report(`edge "${edge.id}" targets unknown node "${edge.to}" (use END to finish)`);
-    }
-  }
+  let reachesEnd = false;
   for (const node of wf.nodes) {
-    if (!wf.edges.some((edge) => edge.from === node.id)) {
-      report(`node "${node.id}" has no outgoing edge (add one to END if it is the last step)`);
+    const seen = new Set;
+    for (const move of node.next) {
+      if (move.to === END) {
+        reachesEnd = true;
+      } else if (!nodes.has(move.to)) {
+        report(`move from "${node.id}" targets unknown node "${move.to}" (use END to finish)`);
+      }
+      if (seen.has(move.to)) {
+        report(`duplicate move ${node.id} -> ${move.to}; transitions must be unambiguous`);
+      }
+      seen.add(move.to);
     }
   }
-  if (!wf.edges.some((edge) => edge.to === END)) {
-    report(`workflow "${wf.id}" has no edge to END`);
+  if (!reachesEnd) {
+    report(`workflow "${wf.id}" has no move to END`);
   }
   if (errors.length === 0) {
     const reachable = new Set([wf.start]);
     const queue = [wf.start];
     while (queue.length > 0) {
       const id = queue.shift();
-      for (const edge of wf.edges) {
-        if (edge.from !== id)
-          continue;
-        if (edge.to === END || reachable.has(edge.to))
+      for (const move of movesFor(wf, id)) {
+        if (move.to === END || reachable.has(move.to))
           continue;
-        reachable.add(edge.to);
-        queue.push(edge.to);
+        reachable.add(move.to);
+        queue.push(move.to);
       }
     }
     for (const node of wf.nodes) {
@@ -396,19 +463,19 @@ function validateWorkflow(raw, source) {
       }
     }
     const canFinish = new Set;
-    for (const edge of wf.edges) {
-      if (edge.to === END)
-        canFinish.add(edge.from);
+    for (const node of wf.nodes) {
+      if (node.next.some((move) => move.to === END))
+        canFinish.add(node.id);
     }
     let grew = true;
     while (grew) {
       grew = false;
-      for (const edge of wf.edges) {
-        if (edge.to === END)
+      for (const node of wf.nodes) {
+        if (canFinish.has(node.id))
           continue;
-        if (!canFinish.has(edge.to) || canFinish.has(edge.from))
+        if (!node.next.some((move) => canFinish.has(move.to)))
           continue;
-        canFinish.add(edge.from);
+        canFinish.add(node.id);
         grew = true;
       }
     }
@@ -420,305 +487,93 @@ function validateWorkflow(raw, source) {
   }
   return { workflow: wf, errors, warnings };
 }
-function outgoingEdges(wf, nodeId) {
-  return wf.edges.filter((edge) => edge.from === nodeId);
+function movesFor(wf, nodeId) {
+  return wf.nodes.find((node) => node.id === nodeId)?.next ?? [];
 }
 function onlyEnd(wf, nodeId) {
-  const out = outgoingEdges(wf, nodeId);
-  return out.length === 1 && out[0].to === END;
-}
-
-// src/workflow/load.ts
-function requireWorkflow(workflows, id) {
-  const workflow = workflows.get(id);
-  if (!workflow) {
-    throw new AppError("workflow_not_found", `workflow "${id}" not found in ./workflows`, 3, {
-      available: [...workflows.keys()].sort()
-    });
-  }
-  return workflow;
-}
-
-// src/commands/workflow.ts
-var ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
-function skeleton(id) {
-  return {
-    id,
-    title: id,
-    start: "start",
-    nodes: [
-      {
-        id: "start",
-        type: "node",
-        title: "Start",
-        description: "Describe the first step."
-      }
-    ],
-    edges: [
-      {
-        id: "e1",
-        from: "start",
-        to: END,
-        description: "Done."
-      }
-    ]
-  };
-}
-function cmdWorkflowNew(workflowsDir, id, json) {
-  if (!id)
-    throw usageError("workflow id is required: next-steps workflow new <id>");
-  if (!ID_PATTERN.test(id)) {
-    throw usageError(`invalid workflow id "${id}"; use A-Z a-z 0-9 . _ - (max 64)`);
-  }
-  const file = join2(workflowsDir, `${id}.json`);
-  if (existsSync2(file)) {
-    throw usageError(`workflow file already exists: ${file}`);
-  }
-  mkdirSync(workflowsDir, { recursive: true });
-  writeFileSync(file, `${JSON.stringify(skeleton(id), null, 2)}
-`, "utf8");
-  if (json)
-    return toJson({ created: file, workflowId: id });
-  return `created: ${file}`;
-}
-function cmdWorkflowList(load, json) {
-  if (json) {
-    return toJson({
-      dir: load.dir,
-      workflows: load.reports.map((report) => ({
-        file: report.file,
-        id: report.id,
-        title: report.title,
-        nodes: report.nodes,
-        edges: report.edges,
-        valid: report.valid,
-        errors: report.errors
-      })),
-      errors: load.errors,
-      warnings: load.warnings
-    });
-  }
-  if (load.reports.length === 0) {
-    return `no workflows in ${load.dir} (run "next-steps workflow new <id>")`;
-  }
-  const rows = load.reports.map((report) => [
-    report.id,
-    report.title,
-    String(report.nodes),
-    String(report.edges),
-    report.valid ? "ok" : "invalid"
-  ]);
-  const body = table(["ID", "TITLE", "NODES", "EDGES", "STATUS"], rows);
-  const failures = load.reports.filter((report) => !report.valid);
-  if (failures.length === 0)
-    return body;
-  const details = failures.flatMap((report) => report.errors.map((error) => `  ${error}`));
-  return `${body}
-
-invalid:
-${details.join(`
-`)}`;
-}
-function findReport(load, id) {
-  if (!id)
-    throw usageError("workflow id is required");
-  const report = load.reports.find((candidate) => candidate.id === id);
-  if (!report) {
-    throw new AppError("workflow_not_found", `workflow "${id}" not found in ${load.dir}`, 3, {
-      available: load.reports.map((candidate) => candidate.id).sort()
-    });
-  }
-  return report;
-}
-function cmdWorkflowShow(load, id, json) {
-  const report = findReport(load, id);
-  if (!report.valid) {
-    throw new AppError("invalid_workflow", `workflow "${report.id}" is invalid`, 5, {
-      errors: report.errors
-    });
-  }
-  const wf = requireWorkflow(load.registry, report.id);
-  if (json)
-    return toJson({ workflow: wf, warnings: report.warnings });
-  const nodeRows = wf.nodes.map((node) => [
-    node.id,
-    node.type,
-    node.type === "subgraph" ? `${node.title} -> ${node.workflow ?? "?"}` : node.title
-  ]);
-  const edgeRows = wf.edges.map((edge) => [
-    edge.id,
-    `${edge.from} -> ${edge.to}`,
-    edge.condition ? `${edge.description}  [when: ${edge.condition}]` : edge.description
-  ]);
-  const indent = (block) => block.split(`
-`).map((line) => `  ${line}`).join(`
-`);
-  return [
-    `${wf.id}  ${wf.title}`,
-    `start: ${wf.start}`,
-    "",
-    "nodes:",
-    indent(table(["ID", "TYPE", "TITLE"], nodeRows)),
-    "",
-    "edges:",
-    indent(table(["ID", "TRANSITION", "DESCRIPTION"], edgeRows))
-  ].join(`
-`);
-}
-function cmdWorkflowCheck(load, id, json) {
-  const reports = id ? [findReport(load, id)] : load.reports;
-  const errors = reports.flatMap((report) => report.errors);
-  const warnings = reports.flatMap((report) => report.warnings);
-  if (errors.length > 0) {
-    throw new AppError("invalid_workflow", "workflow validation failed", 5, { errors });
-  }
-  if (json) {
-    return toJson({
-      ok: true,
-      workflows: reports.map((report) => ({
-        id: report.id,
-        title: report.title,
-        nodes: report.nodes,
-        edges: report.edges
-      })),
-      warnings
-    });
-  }
-  if (reports.length === 0) {
-    return `no workflows in ${load.dir}`;
-  }
-  const lines = reports.map((report) => `ok: ${report.id}  (${report.nodes} nodes, ${report.edges} edges)`);
-  for (const warning of warnings)
-    lines.push(`warning: ${warning}`);
-  return lines.join(`
-`);
+  const moves = movesFor(wf, nodeId);
+  return moves.length === 1 && moves[0]?.to === END;
 }
 
 // src/workflow/graph.ts
 function getNode(wf, id) {
   return wf.nodes.find((node) => node.id === id);
 }
-function effectiveStack(lookup, stack) {
-  const frames = stack.map((frame) => ({ ...frame }));
-  while (frames.length > 1) {
-    const top = frames[frames.length - 1];
-    if (!top || top.nodeId === null)
-      break;
-    const wf = lookup.get(top.workflowId);
-    if (!wf || !onlyEnd(wf, top.nodeId))
-      break;
-    frames.pop();
-  }
-  return frames;
-}
-function computeNext(lookup, session) {
+function computeNext(wf, session) {
   if (session.status === "done") {
-    return {
-      done: true,
-      current: session.current,
-      currentTitle: null,
-      scope: session.stack.map((frame) => frame.workflowId),
-      next: []
-    };
-  }
-  const frames = effectiveStack(lookup, session.stack);
-  const scope = frames.map((frame) => frame.workflowId);
-  const top = frames[frames.length - 1];
-  if (!top) {
-    return { done: true, current: null, currentTitle: null, scope, next: [] };
+    return { done: true, current: session.current, currentTitle: null, next: [] };
   }
-  const wf = lookup.get(top.workflowId);
-  if (!wf) {
-    return { done: true, current: null, currentTitle: null, scope, next: [] };
-  }
-  if (top.nodeId === null) {
+  if (session.current === null) {
     const entry = getNode(wf, wf.start);
     return {
       done: false,
       current: null,
       currentTitle: null,
-      scope,
       next: [
         {
           edge: null,
           node: wf.start,
           title: entry?.title ?? wf.start,
-          description: entry?.description ?? ""
+          description: entry?.description ?? "",
+          reviewRequired: entry?.reviewRequired ?? false
         }
       ]
     };
   }
-  const node = getNode(wf, top.nodeId);
-  if (onlyEnd(wf, top.nodeId)) {
+  const node = getNode(wf, session.current);
+  if (onlyEnd(wf, session.current)) {
     return {
       done: true,
-      current: top.nodeId,
+      current: session.current,
       currentTitle: node?.title ?? null,
-      scope,
       next: []
     };
   }
-  const next = outgoingEdges(wf, top.nodeId).map((edge) => {
-    if (edge.to === END) {
+  const current = session.current;
+  const next = movesFor(wf, current).map((move) => {
+    const edge = `${current}->${move.to}`;
+    if (move.to === END) {
       return {
-        edge: edge.id,
+        edge,
         node: END,
         title: "finish",
-        description: edge.description,
-        ...edge.condition ? { condition: edge.condition } : {}
+        description: move.description,
+        ...move.condition ? { condition: move.condition } : {},
+        reviewRequired: false
       };
     }
-    const target = getNode(wf, edge.to);
+    const target = getNode(wf, move.to);
     return {
-      edge: edge.id,
-      node: edge.to,
-      title: target?.title ?? edge.to,
-      description: edge.description,
-      ...edge.condition ? { condition: edge.condition } : {}
+      edge,
+      node: move.to,
+      title: target?.title ?? move.to,
+      description: move.description,
+      ...move.condition ? { condition: move.condition } : {},
+      reviewRequired: target?.reviewRequired ?? false
     };
   });
   return {
     done: false,
-    current: top.nodeId,
+    current,
     currentTitle: node?.title ?? null,
-    scope,
     next
   };
 }
 
 // src/runs/service.ts
 var KEY_PATTERN = /^[A-Za-z0-9._-]{1,128}$/;
-var MAX_DEPTH = 16;
-function legalOptions(wf, current) {
-  if (current === null) {
-    const entry = getNode(wf, wf.start);
-    return [{ edge: null, node: wf.start, description: entry?.description ?? "" }];
-  }
-  return outgoingEdges(wf, current).map((edge) => ({
-    edge: edge.id,
-    node: edge.to,
-    description: edge.description
-  }));
-}
-function invalidTransition(wf, current, node, scope) {
-  return new AppError("invalid_transition", `cannot move to "${node}" from "${current ?? "(start)"}" in workflow "${wf.id}"`, 4, { current, node, scope, legal: legalOptions(wf, current) });
-}
-function keyNotFound(key) {
-  return new AppError("key_not_found", `session "${key}" does not exist`, 3);
-}
 
 class SessionService {
-  registry;
+  workflow;
   store;
-  constructor(registry, store) {
-    this.registry = registry;
+  constructor(workflow, store) {
+    this.workflow = workflow;
     this.store = store;
   }
   get statePath() {
     return this.store.path;
   }
-  create(input) {
-    const workflow = requireWorkflow(this.registry, input.workflowId);
+  create(input = {}) {
     const key = (input.key ?? "").trim() || crypto.randomUUID();
     if (!KEY_PATTERN.test(key)) {
       throw new AppError("key_invalid", `key "${key}" is invalid; use 1-128 characters from A-Z a-z 0-9 . _ -`, 2);
@@ -726,10 +581,9 @@ class SessionService {
     const now = new Date().toISOString();
     const session = {
       key,
-      workflowId: workflow.id,
+      workflowId: this.workflow.id,
       status: "running",
       current: null,
-      stack: [{ workflowId: workflow.id, nodeId: null }],
       version: 0,
       createdAt: now,
       updatedAt: now
@@ -739,13 +593,14 @@ class SessionService {
     }
     return {
       session,
-      workflowTitle: workflow.title,
-      next: computeNext(this.registry, session)
+      workflowTitle: this.workflow.title,
+      next: computeNext(this.workflow, session)
     };
   }
   log(key, node) {
     return this.store.transaction(() => {
       const session = this.requireSession(key);
+      const wf = this.workflow;
       if (session.status === "done") {
         throw new AppError("invalid_transition", `session "${key}" is already done`, 4, {
           current: END,
@@ -753,82 +608,48 @@ class SessionService {
           legal: []
         });
       }
-      const frames = effectiveStack(this.registry, session.stack);
-      const top = frames[frames.length - 1];
-      if (!top) {
-        throw new AppError("invalid_transition", `session "${key}" has no active scope`, 4);
-      }
-      const wf = requireWorkflow(this.registry, top.workflowId);
-      const scope = frames.map((frame) => frame.workflowId);
       const now = new Date().toISOString();
-      const stack = frames.map((frame) => ({ ...frame }));
+      const from = session.current;
       let stepInput;
-      let current;
-      let endsRun = false;
       if (node === END) {
-        if (top.nodeId === null)
-          throw invalidTransition(wf, top.nodeId, node, scope);
-        const edge = outgoingEdges(wf, top.nodeId).find((candidate) => candidate.to === END);
-        if (!edge)
-          throw invalidTransition(wf, top.nodeId, node, scope);
+        if (from === null || !movesFor(wf, from).some((move) => move.to === END)) {
+          throw this.invalidTransition(from, node);
+        }
         stepInput = {
           key,
           node: END,
-          from: top.nodeId,
-          edge: edge.id,
-          workflowId: top.workflowId,
-          scope,
+          from,
+          edge: `${from}->${END}`,
+          workflowId: wf.id,
           at: now
         };
-        if (stack.length === 1) {
-          current = END;
-          endsRun = true;
-        } else {
-          stack.pop();
-          current = stack[stack.length - 1]?.nodeId ?? null;
-        }
+        session.current = END;
+        session.status = "done";
       } else {
         const target = getNode(wf, node);
         if (!target) {
-          throw new AppError("unknown_node", `node "${node}" does not exist in workflow "${wf.id}"`, 4, { legal: legalOptions(wf, top.nodeId) });
+          throw new AppError("unknown_node", `node "${node}" does not exist in workflow "${wf.id}"`, 4, { legal: this.legalOptions(from) });
         }
         let edge = null;
-        if (top.nodeId === null) {
+        if (from === null) {
           if (node !== wf.start)
-            throw invalidTransition(wf, top.nodeId, node, scope);
+            throw this.invalidTransition(from, node);
         } else {
-          const found = outgoingEdges(wf, top.nodeId).find((candidate) => candidate.to === node);
-          if (!found)
-            throw invalidTransition(wf, top.nodeId, node, scope);
-          edge = found;
-        }
-        const last = stack[stack.length - 1];
-        if (last)
-          last.nodeId = node;
-        if (target.type === "subgraph") {
-          if (stack.length >= MAX_DEPTH) {
-            throw new AppError("max_depth_exceeded", `subgraph nesting exceeded ${MAX_DEPTH} levels`, 4, { scope });
+          if (!movesFor(wf, from).some((move) => move.to === node)) {
+            throw this.invalidTransition(from, node);
           }
-          const child = requireWorkflow(this.registry, target.workflow);
-          stack.push({ workflowId: child.id, nodeId: null });
+          edge = `${from}->${node}`;
+        }
+        stepInput = { key, node, from, edge, workflowId: wf.id, at: now };
+        session.current = node;
+        if (onlyEnd(wf, node)) {
+          session.current = END;
+          session.status = "done";
         }
-        current = node;
-        stepInput = {
-          key,
-          node,
-          from: top.nodeId,
-          edge: edge?.id ?? null,
-          workflowId: top.workflowId,
-          scope,
-          at: now
-        };
       }
-      session.stack = stack;
-      session.current = current;
-      session.status = endsRun ? "done" : "running";
       session.version += 1;
       session.updatedAt = now;
-      const next = this.settle(session);
+      const next = computeNext(wf, session);
       const step = this.store.appendStep(stepInput);
       this.store.updateSession(session);
       return { session, step, next };
@@ -836,40 +657,44 @@ class SessionService {
   }
   next(key) {
     const session = this.requireSession(key);
-    return { session, next: computeNext(this.registry, session) };
+    return { session, next: computeNext(this.workflow, session) };
   }
   steps(key, query = {}) {
     const session = this.requireSession(key);
     return { session, steps: this.store.listSteps(key, query) };
   }
-  keys(workflowId) {
-    if (workflowId)
-      requireWorkflow(this.registry, workflowId);
-    return this.store.listSessions(workflowId);
+  keys() {
+    return this.store.listSessions();
   }
   reset(key) {
     this.requireSession(key);
     return { key, deletedSteps: this.store.reset(key) };
   }
-  settle(session) {
-    const next = computeNext(this.registry, session);
-    if (!next.done)
-      return next;
-    session.status = "done";
-    session.current = END;
-    return computeNext(this.registry, session);
+  legalOptions(from) {
+    if (from === null) {
+      const entry = getNode(this.workflow, this.workflow.start);
+      return [{ edge: null, node: this.workflow.start, description: entry?.description ?? "" }];
+    }
+    return movesFor(this.workflow, from).map((move) => ({
+      edge: `${from}->${move.to}`,
+      node: move.to,
+      description: move.description
+    }));
+  }
+  invalidTransition(from, node) {
+    return new AppError("invalid_transition", `cannot move to "${node}" from "${from ?? "(start)"}" in workflow "${this.workflow.id}"`, 4, { current: from, node, legal: this.legalOptions(from) });
   }
   requireSession(key) {
     const session = this.store.getSession(key);
     if (!session)
-      throw keyNotFound(key);
+      throw new AppError("key_not_found", `session "${key}" does not exist`, 3);
     return session;
   }
 }
 
 // src/runs/store.ts
-import { mkdirSync as mkdirSync2 } from "node:fs";
-import { dirname as dirname2 } from "node:path";
+import { mkdirSync as mkdirSync2, unlinkSync } from "node:fs";
+import { dirname as dirname3 } from "node:path";
 
 // src/runs/driver.ts
 import { createRequire as createRequire2 } from "node:module";
@@ -948,7 +773,6 @@ CREATE TABLE IF NOT EXISTS runs (
   workflow_id TEXT NOT NULL,
   status      TEXT NOT NULL,
   current     TEXT,
-  stack       TEXT NOT NULL,
   version     INTEGER NOT NULL DEFAULT 0,
   created_at  TEXT NOT NULL,
   updated_at  TEXT NOT NULL
@@ -961,18 +785,17 @@ CREATE TABLE IF NOT EXISTS steps (
   from_node   TEXT,
   edge        TEXT,
   workflow_id TEXT NOT NULL,
-  scope       TEXT NOT NULL,
   at          TEXT NOT NULL,
   PRIMARY KEY (key, seq)
 );
 `;
+var LEGACY_COLUMNS = new Set(["stack", "scope"]);
 function toSession(row) {
   return {
     key: row.key,
     workflowId: row.workflow_id,
     status: row.status,
     current: row.current,
-    stack: JSON.parse(row.stack),
     version: row.version,
     createdAt: row.created_at,
     updatedAt: row.updated_at
@@ -986,7 +809,6 @@ function toStep(row) {
     from: row.from_node,
     edge: row.edge,
     workflowId: row.workflow_id,
-    scope: JSON.parse(row.scope),
     at: row.at
   };
 }
@@ -997,25 +819,42 @@ class SqliteRunStore {
   constructor(path) {
     this.path = path;
     if (path !== ":memory:") {
-      mkdirSync2(dirname2(path), { recursive: true });
+      mkdirSync2(dirname3(path), { recursive: true });
     }
     this.db = openDriver(path);
-    this.db.exec("PRAGMA foreign_keys = ON;");
-    this.db.exec("PRAGMA busy_timeout = 5000;");
     if (path !== ":memory:") {
+      if (this.isOutdated())
+        this.recreate(path);
       this.db.exec("PRAGMA journal_mode = WAL;");
     }
+    this.db.exec("PRAGMA foreign_keys = ON;");
+    this.db.exec("PRAGMA busy_timeout = 5000;");
     this.db.exec(SCHEMA);
   }
+  isOutdated() {
+    const columns = [
+      ...this.db.all("PRAGMA table_info(runs)", []),
+      ...this.db.all("PRAGMA table_info(steps)", [])
+    ];
+    return columns.some((column) => LEGACY_COLUMNS.has(column.name));
+  }
+  recreate(path) {
+    this.db.close();
+    for (const suffix of ["", "-wal", "-shm"]) {
+      try {
+        unlinkSync(`${path}${suffix}`);
+      } catch {}
+    }
+    this.db = openDriver(path);
+  }
   createSession(session) {
     return this.db.run(`INSERT OR IGNORE INTO runs
-           (key, workflow_id, status, current, stack, version, created_at, updated_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [
+           (key, workflow_id, status, current, version, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?)`, [
       session.key,
       session.workflowId,
       session.status,
       session.current,
-      JSON.stringify(session.stack),
       session.version,
       session.createdAt,
       session.updatedAt
@@ -1027,32 +866,16 @@ class SqliteRunStore {
   }
   updateSession(session) {
     this.db.run(`UPDATE runs
-          SET status = ?, current = ?, stack = ?, version = ?, updated_at = ?
-        WHERE key = ?`, [
-      session.status,
-      session.current,
-      JSON.stringify(session.stack),
-      session.version,
-      session.updatedAt,
-      session.key
-    ]);
+          SET status = ?, current = ?, version = ?, updated_at = ?
+        WHERE key = ?`, [session.status, session.current, session.version, session.updatedAt, session.key]);
   }
   appendStep(step) {
     const row = this.db.get("SELECT COALESCE(MAX(seq), 0) + 1 AS next FROM steps WHERE key = ?", [
       step.key
     ]);
     const seq = row?.next ?? 1;
-    this.db.run(`INSERT INTO steps (key, seq, node, from_node, edge, workflow_id, scope, at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`, [
-      step.key,
-      seq,
-      step.node,
-      step.from,
-      step.edge,
-      step.workflowId,
-      JSON.stringify(step.scope),
-      step.at
-    ]);
+    this.db.run(`INSERT INTO steps (key, seq, node, from_node, edge, workflow_id, at)
+       VALUES (?, ?, ?, ?, ?, ?, ?)`, [step.key, seq, step.node, step.from, step.edge, step.workflowId, step.at]);
     return { ...step, seq };
   }
   listSteps(key, query = {}) {
@@ -1061,10 +884,8 @@ class SqliteRunStore {
     const rows = this.db.all("SELECT * FROM steps WHERE key = ? AND seq > ? ORDER BY seq ASC LIMIT ?", [key, after, limit]);
     return rows.map(toStep);
   }
-  listSessions(workflowId) {
-    const rows = workflowId ? this.db.all("SELECT * FROM runs WHERE workflow_id = ? ORDER BY updated_at DESC", [
-      workflowId
-    ]) : this.db.all("SELECT * FROM runs ORDER BY updated_at DESC", []);
+  listSessions() {
+    const rows = this.db.all("SELECT * FROM runs ORDER BY updated_at DESC", []);
     return rows.map(toSession);
   }
   reset(key) {
@@ -1095,130 +916,49 @@ class AppError2 extends Error {
 }
 
 // src/workflow/load.ts
-import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync2 } from "node:fs";
-import { join as join3 } from "node:path";
-function rawId(raw) {
-  return typeof raw === "object" && raw !== null && typeof raw.id === "string" ? raw.id : "(invalid)";
-}
-function loadWorkflows(dir) {
-  const registry = new Map;
-  const reports = [];
-  if (!existsSync3(dir)) {
-    const message = `workflow directory not found: ${dir} (run "next-steps workflow new <id>")`;
-    return { dir, registry, reports, errors: [message], warnings: [] };
-  }
-  const parsed = [];
-  for (const file of readdirSync(dir).filter((name) => name.endsWith(".json")).sort()) {
-    const path = join3(dir, file);
-    let raw;
-    try {
-      raw = JSON.parse(readFileSync2(path, "utf8"));
-    } catch (error) {
-      const message = `${file}: invalid JSON (${error instanceof Error ? error.message : String(error)})`;
-      reports.push({
-        file,
-        id: "(unreadable)",
-        title: "",
-        nodes: 0,
-        edges: 0,
-        valid: false,
-        errors: [message],
-        warnings: []
-      });
-      continue;
-    }
-    const check = validateWorkflow(raw, file);
-    if (check.workflow) {
-      parsed.push({
-        file,
-        workflow: check.workflow,
-        errors: check.errors,
-        warnings: check.warnings
-      });
-    } else {
-      reports.push({
-        file,
-        id: rawId(raw),
-        title: "",
-        nodes: 0,
-        edges: 0,
-        valid: false,
-        errors: check.errors,
-        warnings: check.warnings
-      });
-    }
-  }
-  const byId = new Map;
-  for (const entry of parsed) {
-    const group = byId.get(entry.workflow.id) ?? [];
-    group.push(entry);
-    byId.set(entry.workflow.id, group);
-  }
-  for (const [id, group] of byId) {
-    if (group.length < 2)
-      continue;
-    const message = `workflow id "${id}" is defined in more than one file: ${group.map((entry) => entry.file).join(", ")}`;
-    for (const entry of group)
-      entry.errors.push(message);
-  }
-  const knownIds = new Set(parsed.map((entry) => entry.workflow.id));
-  for (const entry of parsed) {
-    for (const node of entry.workflow.nodes) {
-      if (node.type !== "subgraph" || !node.workflow)
-        continue;
-      if (!knownIds.has(node.workflow)) {
-        entry.errors.push(`${entry.file}: subgraph node "${node.id}" references unknown workflow "${node.workflow}"`);
-      }
-    }
-  }
-  for (const entry of parsed) {
-    const valid = entry.errors.length === 0;
-    reports.push({
-      file: entry.file,
-      id: entry.workflow.id,
-      title: entry.workflow.title,
-      nodes: entry.workflow.nodes.length,
-      edges: entry.workflow.edges.length,
-      valid,
-      errors: entry.errors,
-      warnings: entry.warnings
-    });
-    if (valid)
-      registry.set(entry.workflow.id, entry.workflow);
+import { readFileSync as readFileSync2 } from "node:fs";
+function loadWorkflowFile(path) {
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync2(path, "utf8"));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const missing = error.code === "ENOENT";
+    return {
+      path,
+      errors: [
+        missing ? `workflow file not found: ${path} (run "next-steps workflow new")` : `${path}: invalid JSON (${message})`
+      ],
+      warnings: []
+    };
   }
-  return {
-    dir,
-    registry,
-    reports,
-    errors: reports.flatMap((report) => report.errors),
-    warnings: reports.flatMap((report) => report.warnings)
-  };
+  const check = validateWorkflow(raw, path);
+  return { path, workflow: check.workflow, errors: check.errors, warnings: check.warnings };
 }
 
 // src/cli.ts
-var VERSION = "0.1.0";
+var VERSION = "0.1.1";
 var HELP = `next-steps \u2014 record the current step, ask what comes next
 
 usage:
-  next-steps create  --workflow <id> [--key <key>] [--json]
+  next-steps create  [--key <key>] [--json]
   next-steps log     --key <key> --node <node> [--json]
   next-steps next    --key <key> [--json]
   next-steps steps   --key <key> [--limit <n>] [--after <seq>] [--json]
-  next-steps keys    [--workflow <id>] [--json]
+  next-steps keys    [--json]
   next-steps reset   --key <key> [--json]
 
-  next-steps workflow new <id> [--json]
-  next-steps workflow list [--json]
-  next-steps workflow show <id> [--json]
-  next-steps workflow check [id] [--json]
+  next-steps workflow new [--json]
+  next-steps workflow show [--json]
+  next-steps workflow check [--json]
 
-  next-steps viz [--port <n>] [--json]   (serve a graph viewer on a local port)
+  next-steps viz [--port <n>] [--json]   (serve the graph viewer on a local port)
 
   next-steps help
   next-steps version
 
-state:   ./.next-steps/state.db   (created on first use, gitignored)
-graphs:  ./workflows/*.json
+state:   ./.next-steps/state.db       (created on first use, gitignored)
+graph:   ./.next-steps/workflow.json  (one graph per project, committed)
 
 exit codes:
   0 ok   2 usage   3 not found   4 invalid transition   5 invalid workflow`;
@@ -1232,19 +972,25 @@ function parseOptions(args, options, allowPositionals = false) {
 function asString(value) {
   return typeof value === "string" ? value : undefined;
 }
-function requireRegistry(workflowsDir) {
-  const load = loadWorkflows(workflowsDir);
-  if (load.errors.length > 0) {
-    throw new AppError2("invalid_workflow", "workflow files are invalid", 5, {
+function requireGraphFile(graphPath) {
+  if (existsSync3(graphPath))
+    return;
+  throw new AppError2("workflow_not_found", `workflow file not found: ${graphPath} (run "next-steps workflow new")`, 3);
+}
+function requireWorkflow(graphPath) {
+  requireGraphFile(graphPath);
+  const load = loadWorkflowFile(graphPath);
+  if (load.errors.length > 0 || !load.workflow) {
+    throw new AppError2("invalid_workflow", "workflow file is invalid", 5, {
       errors: load.errors
     });
   }
-  return load.registry;
+  return load.workflow;
 }
 function execute(argv, options) {
   const cwd = options.cwd ?? process.cwd();
-  const workflowsDir = options.workflowsDir ?? join4(cwd, "workflows");
-  const dbPath = options.dbPath ?? join4(cwd, ".next-steps", "state.db");
+  const graphPath = options.graphPath ?? join2(cwd, ".next-steps", "workflow.json");
+  const dbPath = options.dbPath ?? join2(cwd, ".next-steps", "state.db");
   const [command, ...rest] = argv;
   if (!command || command === "help" || command === "--help" || command === "-h") {
     return HELP;
@@ -1254,21 +1000,21 @@ function execute(argv, options) {
   }
   if (command === "workflow") {
     const { positionals, values } = parseOptions(rest, { json: { type: "boolean" } }, true);
-    const [subcommand, id] = positionals;
+    const [subcommand] = positionals;
     const json = Boolean(values.json);
-    const load = loadWorkflows(workflowsDir);
-    switch (subcommand) {
-      case "new":
-        return cmdWorkflowNew(workflowsDir, id, json);
-      case "list":
-        return cmdWorkflowList(load, json);
-      case "show":
-        return cmdWorkflowShow(load, id, json);
-      case "check":
-        return cmdWorkflowCheck(load, id, json);
-      default:
-        throw usageError2("usage: next-steps workflow <new|list|show|check> ...");
+    if (subcommand === "new") {
+      if (positionals.length > 1)
+        throw usageError2(`unexpected argument "${positionals[1]}"`);
+      return cmdWorkflowNew(graphPath, basename(cwd), json);
+    }
+    if (subcommand !== "show" && subcommand !== "check") {
+      throw usageError2("usage: next-steps workflow <new|show|check> [--json]");
     }
+    if (positionals.length > 1)
+      throw usageError2(`unexpected argument "${positionals[1]}"`);
+    requireGraphFile(graphPath);
+    const load = loadWorkflowFile(graphPath);
+    return subcommand === "show" ? cmdWorkflowShow(load, json) : cmdWorkflowCheck(load, json);
   }
   if (command === "viz") {
     const { values } = parseOptions(rest, { port: { type: "string" }, json: { type: "boolean" } });
@@ -1276,27 +1022,21 @@ function execute(argv, options) {
     if (port < 1 || port > 65535) {
       throw usageError2("--port must be between 1 and 65535");
     }
-    const registry2 = requireRegistry(workflowsDir);
-    if (registry2.size === 0) {
-      throw new AppError2("no_workflows", `no workflows in ${workflowsDir}`, 3);
-    }
-    const result = startVizServer(registry2, port);
-    return values.json ? toJson2({ url: result.url, workflows: result.workflows }) : `viewer: ${result.url}
+    const result = startVizServer(requireWorkflow(graphPath), port);
+    return values.json ? toJson2({ url: result.url, workflow: result.workflow }) : `viewer: ${result.url}
 press Ctrl+C to stop`;
   }
-  const registry = requireRegistry(workflowsDir);
+  const workflow = requireWorkflow(graphPath);
   const store = new SqliteRunStore(dbPath);
   try {
-    const service = new SessionService(registry, store);
+    const service = new SessionService(workflow, store);
     switch (command) {
       case "create": {
         const { values } = parseOptions(rest, {
-          workflow: { type: "string" },
           key: { type: "string" },
           json: { type: "boolean" }
         });
         return cmdCreate(service, {
-          workflowId: asString(values.workflow),
           key: asString(values.key),
           json: Boolean(values.json)
         });
@@ -1338,14 +1078,8 @@ press Ctrl+C to stop`;
         });
       }
       case "keys": {
-        const { values } = parseOptions(rest, {
-          workflow: { type: "string" },
-          json: { type: "boolean" }
-        });
-        return cmdKeys(service, {
-          workflowId: asString(values.workflow),
-          json: Boolean(values.json)
-        });
+        const { values } = parseOptions(rest, { json: { type: "boolean" } });
+        return cmdKeys(service, { json: Boolean(values.json) });
       }
       case "reset": {
         const { values } = parseOptions(rest, {