agent-method 1.5.12

package/lib/cli/record.js

@@ -0,0 +1,98 @@
+/**
+ * wwa record — append the last CLI run summary to SESSION-LOG.md.
+ */
+
+import { readFileSync, existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { findSessionLog, safeWriteFile } from "./helpers.js";
+import {
+  readLastRunSummary,
+  clearLastRunSummary,
+  parseLastRunContent,
+} from "./report-helpers.js";
+
+export function register(program) {
+  program
+    .command("record [directory]")
+    .description("Record the last CLI run summary to SESSION-LOG.md")
+    .option("-d, --directory <path>", "Project directory", ".")
+    .option("--dry-run", "Show what would be appended without writing")
+    .option("--json", "Output as JSON")
+    .action(async (directory, cmd) => {
+      const opts = typeof cmd?.opts === "function" ? cmd.opts() : (cmd || {});
+      const dir = resolve(opts.directory || directory || ".");
+      const content = readLastRunSummary(dir);
+
+      if (!content) {
+        const msg =
+          "No recent CLI output to record. Run a wwa command (e.g. wwa route '…', wwa scan) first.";
+        if (opts.json) {
+          console.log(JSON.stringify({ recorded: false, error: msg }, null, 2));
+        } else {
+          console.log(`\n  ${msg}\n`);
+        }
+        return;
+      }
+
+      const parsed = parseLastRunContent(content);
+      if (!parsed) {
+        const msg = "Last run file was invalid; nothing to record.";
+        if (opts.json) {
+          console.log(JSON.stringify({ recorded: false, error: msg }, null, 2));
+        } else {
+          console.log(`\n  ${msg}\n`);
+        }
+        return;
+      }
+
+      const date = parsed.timestamp.slice(0, 10);
+      const block = [
+        "",
+        `### CLI run — ${date} — ${parsed.command}`,
+        "",
+        `Command: wwa ${parsed.command}`,
+        `Input: ${parsed.inputRef}`,
+        `Summary: ${parsed.summary}`,
+        "",
+      ].join("\n");
+
+      const sessionLog = findSessionLog(dir);
+      if (!sessionLog) {
+        const msg = "No SESSION-LOG.md found. Create it or run from project root.";
+        if (opts.json) {
+          console.log(JSON.stringify({ recorded: false, error: msg }, null, 2));
+        } else {
+          console.log(`\n  ${msg}\n`);
+        }
+        return;
+      }
+
+      if (opts.dryRun) {
+        if (opts.json) {
+          console.log(
+            JSON.stringify(
+              { dryRun: true, target: sessionLog, block: block.trim() },
+              null,
+              2
+            )
+          );
+        } else {
+          console.log("\n  Dry run — would append to", sessionLog);
+          console.log(block);
+        }
+        return;
+      }
+
+      const existing = readFileSync(sessionLog, "utf-8");
+      safeWriteFile(sessionLog, existing + block, "utf-8");
+      clearLastRunSummary(dir);
+
+      if (opts.json) {
+        console.log(
+          JSON.stringify({ recorded: true, target: sessionLog }, null, 2)
+        );
+      } else {
+        console.log("\n  Recorded last CLI run to SESSION-LOG.md.\n");
+      }
+    });
+}

package/lib/cli/refine.js

@@ -0,0 +1,202 @@
+/** wwa refine — extract refinement report from session history. */
+
+import { readFileSync, existsSync } from "node:fs";
+import { findSessionLog, safeWriteFile } from "./helpers.js";
+
+export function register(program) {
+  program
+    .command("refine [session-log]")
+    .description("Extract a refinement report from session history")
+    .option("-o, --output <path>", "Output file (default: stdout)")
+    .option("--json", "Output as JSON")
+    .action(async (sessionLog, opts) => {
+      if (!sessionLog) {
+        sessionLog = findSessionLog(".");
+        if (!sessionLog) {
+          console.error(
+            "No SESSION-LOG.md found in current directory.\n" +
+              "Specify a path: wwa refine path/to/SESSION-LOG.md"
+          );
+          process.exit(1);
+        }
+      }
+
+      if (!existsSync(sessionLog)) {
+        console.error(`File not found: ${sessionLog}`);
+        process.exit(1);
+      }
+
+      const content = readFileSync(sessionLog, "utf-8");
+      const parsed = parseSessionLog(content);
+
+      let result;
+      if (opts.json) {
+        result = JSON.stringify(parsed, null, 2);
+      } else {
+        result = generateRefinementReport(parsed);
+      }
+
+      if (opts.output) {
+        safeWriteFile(opts.output, result, "utf-8");
+        console.log(
+          `Refinement report written to ${opts.output} (${parsed.entries.length} sessions)`
+        );
+      } else {
+        console.log(result);
+      }
+    });
+}
+
+// ---------------------------------------------------------------------------
+// Session log parsing
+// ---------------------------------------------------------------------------
+
+function parseSessionLog(content) {
+  const context = {};
+  const ctxMatch = content.match(
+    /## Project context\s*\n\s*\|[^\n]+\n\s*\|[-| ]+\n((?:\|[^\n]+\n)*)/
+  );
+  if (ctxMatch) {
+    for (const row of ctxMatch[1].trim().split("\n")) {
+      const cols = row
+        .split("|")
+        .map((c) => c.trim())
+        .filter((c) => c);
+      if (cols.length >= 2) {
+        context[cols[0].toLowerCase()] = cols[1];
+      }
+    }
+  }
+
+  const entries = [];
+  const entryPattern =
+    /###\s+S(\d+)\s*(?:\u2014|--)\s*(\S+)\s*(?:\u2014|--)\s*(.+?)$(.*?)(?=###\s+S\d+|$)/gms;
+  let m;
+  while ((m = entryPattern.exec(content)) !== null) {
+    const [, num, date, title, body] = m;
+    const entry = { session: parseInt(num, 10), date, title: title.trim() };
+
+    for (const line of body.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const segments = trimmed.split("|").map((s) => s.trim());
+      for (const seg of segments) {
+        if (seg.includes(":")) {
+          const idx = seg.indexOf(":");
+          const key = seg.slice(0, idx).trim().toLowerCase();
+          const val = seg.slice(idx + 1).trim();
+          if (
+            [
+              "model", "profile", "workflow", "queries",
+              "features", "cascades", "decisions", "friction", "finding",
+            ].includes(key)
+          ) {
+            entry[key] = val;
+          }
+        }
+      }
+    }
+    entries.push(entry);
+  }
+
+  return { context, entries };
+}
+
+function generateRefinementReport(parsed) {
+  const ctx = parsed.context;
+  const entries = parsed.entries;
+
+  const project = ctx["project name"] || "Unknown";
+  const ptype = ctx["project type"] || "unknown";
+  const profile = ctx["integration profile"] || "unknown";
+  const extensions = ctx["extension(s)"] || "none";
+
+  const workflows = new Set();
+  let totalFriction = 0;
+  let totalFindings = 0;
+  const findingsList = [];
+  const frictionList = [];
+
+  for (const e of entries) {
+    if (e.workflow) workflows.add(e.workflow);
+    const friction = e.friction || "none";
+    if (friction.toLowerCase() !== "none" && friction) {
+      totalFriction++;
+      frictionList.push(`S${e.session} (${e.date}): ${friction}`);
+    }
+    const finding = e.finding || "none";
+    if (finding.toLowerCase() !== "none" && finding) {
+      totalFindings++;
+      findingsList.push(`S${e.session} (${e.date}): ${finding}`);
+    }
+  }
+
+  const wfSorted = [...workflows].sort().join(", ") || "none";
+  const lines = [
+    `# Refinement Report: ${project}`,
+    "",
+    "Auto-generated from SESSION-LOG.md by `wwa refine`.",
+    "",
+    "## Source",
+    "",
+    "| Field | Value |",
+    "|-------|-------|",
+    `| Project type | ${ptype} |`,
+    `| Extension(s) | ${extensions} |`,
+    `| Workflow(s) exercised | ${wfSorted} |`,
+    `| Integration profile | ${profile} |`,
+    `| Sessions | ${entries.length} |`,
+    "",
+    "## Session summary",
+    "",
+    "| # | Date | Title | Workflow | Friction | Finding |",
+    "|---|------|-------|----------|----------|---------|",
+  ];
+
+  for (const e of entries) {
+    const friction = e.friction || "none";
+    const finding = e.finding || "none";
+    const wf = e.workflow || "\u2014";
+    lines.push(
+      `| S${e.session} | ${e.date} | ${e.title} | ${wf} | ${friction} | ${finding} |`
+    );
+  }
+
+  lines.push(
+    "", "## Statistics", "",
+    `- **Total sessions**: ${entries.length}`,
+    `- **Workflows used**: ${wfSorted}`,
+    `- **Sessions with friction**: ${totalFriction}`,
+    `- **Sessions with findings**: ${totalFindings}`,
+    ""
+  );
+
+  if (frictionList.length > 0) {
+    lines.push("## Friction points", "");
+    for (const f of frictionList) lines.push(`- ${f}`);
+    lines.push("");
+  }
+
+  if (findingsList.length > 0) {
+    lines.push("## Findings", "");
+    for (const f of findingsList) lines.push(`- ${f}`);
+    lines.push("");
+  }
+
+  lines.push(
+    "## Dimension scores", "",
+    "Fill in after reviewing the session data above:", "",
+    "| Dimension | Score | One-line summary |",
+    "|-----------|:-----:|-----------------|",
+    "| Context quality | \u2014 | |",
+    "| Decision preservation | \u2014 | |",
+    "| Scope discipline | \u2014 | |",
+    "| Cascade coverage | \u2014 | |",
+    "| Audit completeness | \u2014 | |",
+    "| Bootstrap speed | \u2014 | |",
+    "| Lifecycle fit | \u2014 | |",
+    "| Model adequacy | \u2014 | |"
+  );
+
+  return lines.join("\n") + "\n";
+}

package/lib/cli/report-helpers.js

@@ -0,0 +1,113 @@
+/**
+ * CLI report and last-run summary helpers.
+ * Used to print human-readable input + summary and to persist the last run for `wwa record`.
+ */
+
+import { readFileSync, existsSync, mkdirSync, unlinkSync } from "node:fs";
+import { resolve, join } from "node:path";
+import { safeWriteFile } from "./helpers.js";
+
+const LAST_RUN_FILENAME = "last-cli-run.md";
+const LAST_RUN_DIR = ".context";
+
+/**
+ * Print the standard CLI report block (input reference + summary).
+ * Call before printing command-specific detail when not --json.
+ * @param {{ command: string, inputRef: string, summary: string, skipDetail?: boolean }} opts
+ */
+export function printCliReport(opts) {
+  const { command, inputRef, summary, skipDetail } = opts;
+  console.log("\n  Input");
+  console.log(`    Command: wwa ${command}`);
+  console.log(`    ${inputRef}`);
+  console.log("\n  Summary");
+  for (const line of summary.split("\n").filter(Boolean)) {
+    console.log(`    ${line.trim()}`);
+  }
+  if (!skipDetail) {
+    console.log("");
+  }
+}
+
+/**
+ * Path to the last-run file under the given project root.
+ * @param {string} dir - Project root (resolved)
+ */
+function lastRunPath(dir) {
+  return join(resolve(dir), LAST_RUN_DIR, LAST_RUN_FILENAME);
+}
+
+/**
+ * Write the last-run summary so `wwa record` can append it to SESSION-LOG.
+ * Only call when not --json. Creates .context/ if needed.
+ * @param {string} dir - Project root
+ * @param {{ command: string, inputRef: string, summary: string }} data
+ */
+export function writeLastRunSummary(dir, data) {
+  const d = resolve(dir);
+  const dirPath = join(d, LAST_RUN_DIR);
+  if (!existsSync(dirPath)) {
+    mkdirSync(dirPath, { recursive: true });
+  }
+  const ts = new Date().toISOString();
+  const content = [
+    `command: ${data.command}`,
+    `inputRef: ${data.inputRef.replace(/\n/g, " ")}`,
+    `summary: ${data.summary.replace(/\n/g, " ").trim()}`,
+    `timestamp: ${ts}`,
+  ].join("\n");
+  const path = lastRunPath(d);
+  safeWriteFile(path, content, "utf-8");
+}
+
+/**
+ * Read the last-run summary content, or null if missing.
+ * @param {string} dir - Project root
+ * @returns {string | null}
+ */
+export function readLastRunSummary(dir) {
+  const path = lastRunPath(resolve(dir));
+  if (!existsSync(path)) return null;
+  try {
+    return readFileSync(path, "utf-8").trim();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Remove the last-run file after a successful record.
+ * @param {string} dir - Project root
+ */
+export function clearLastRunSummary(dir) {
+  const path = lastRunPath(resolve(dir));
+  if (existsSync(path)) {
+    try {
+      unlinkSync(path);
+    } catch {
+      // ignore
+    }
+  }
+}
+
+/**
+ * Parse last-run file content into { command, inputRef, summary, timestamp }.
+ * @param {string} content
+ * @returns {{ command: string, inputRef: string, summary: string, timestamp: string } | null}
+ */
+export function parseLastRunContent(content) {
+  if (!content || !content.trim()) return null;
+  const out = { command: "", inputRef: "", summary: "", timestamp: "" };
+  for (const line of content.split("\n")) {
+    const colon = line.indexOf(":");
+    if (colon <= 0) continue;
+    const key = line.slice(0, colon).trim();
+    const val = line.slice(colon + 1).trim();
+    if (key === "command") out.command = val;
+    else if (key === "inputRef") out.inputRef = val;
+    else if (key === "summary") out.summary = val;
+    else if (key === "timestamp") out.timestamp = val;
+  }
+  if (!out.command) return null;
+  return out;
+}

package/lib/cli/review.js

@@ -0,0 +1,76 @@
+/** wwa review — display project review dashboard. */
+
+import { readFileSync, existsSync } from "node:fs";
+import { resolve, join } from "node:path";
+import { printCliReport, writeLastRunSummary } from "./report-helpers.js";
+
+export function register(program) {
+  program
+    .command("review [directory]")
+    .description("Display project review dashboard from Reviews/INDEX.md")
+    .option("--json", "Output as JSON")
+    .action(async (directory, opts) => {
+      directory = directory || ".";
+      const d = resolve(directory);
+
+      const reviewIndex = join(d, "Reviews", "INDEX.md");
+      const hasReviews = existsSync(reviewIndex);
+
+      // Fallback: synthesize from intelligence layer files
+      const sources = {
+        roadmap: join(d, "ROADMAP.md"),
+        plan: join(d, "PLAN.md"),
+        state: join(d, "STATE.md"),
+        requirements: join(d, "REQUIREMENTS.md"),
+        backlog: join(d, "todos", "backlog.md"),
+      };
+
+      const available = {};
+      for (const [key, path] of Object.entries(sources)) {
+        available[key] = existsSync(path);
+      }
+
+      if (opts.json) {
+        const data = { hasReviewsDir: hasReviews, available };
+        if (hasReviews) {
+          data.indexContent = readFileSync(reviewIndex, "utf-8");
+        }
+        console.log(JSON.stringify(data, null, 2));
+        return;
+      }
+
+      const inputRef = `directory=${directory}`;
+      if (hasReviews) {
+        const content = readFileSync(reviewIndex, "utf-8");
+        const summary = "Reviews/INDEX.md found. Dashboard content below.";
+        printCliReport({ command: "review", inputRef, summary });
+        console.log("  Detail\n");
+        console.log(content);
+        writeLastRunSummary(d, { command: "review", inputRef, summary });
+        return;
+      }
+
+      const count = Object.values(available).filter(Boolean).length;
+      const summary = `No Reviews/ directory. ${count} source(s) available (roadmap, plan, state, requirements, backlog). Use full template for full reviews.`;
+      printCliReport({ command: "review", inputRef, summary });
+      console.log("  Detail — Project Review Dashboard\n");
+      console.log("  No Reviews/ directory found. Showing available sources:\n");
+
+      for (const [key, path] of Object.entries(sources)) {
+        if (available[key]) {
+          const content = readFileSync(path, "utf-8");
+          const lines = content.split("\n").length;
+          const title = content.match(/^#\s+(.+)$/m)?.[1] || key;
+          console.log(`    [+] ${key.padEnd(14)} ${title} (${lines} lines)`);
+        } else {
+          console.log(`    [ ] ${key.padEnd(14)} not found`);
+        }
+      }
+
+      console.log(
+        "\n  To get full reviews, use the full template tier:" +
+          "\n    wwa init <type> --tier full\n"
+      );
+      writeLastRunSummary(d, { command: "review", inputRef, summary });
+    });
+}

package/lib/cli/routable.js

@@ -0,0 +1,109 @@
+/**
+ * Phase 7p routable workflow commands.
+ * Each command invokes the pipeline with a fixed query_type (no natural-language classification).
+ */
+
+import {
+  resolveProjectType,
+  getPipeline,
+  loadRegistryData,
+} from "./helpers.js";
+import { orderByDependencies } from "../dependencies.js";
+import { loadDocGraph } from "../boundaries.js";
+import { printCliReport, writeLastRunSummary } from "./report-helpers.js";
+
+const ROUTABLE_COMMANDS = [
+  // Phase 1 set (Phase 7p)
+  { name: "project-discovery", queryType: "project_discovery", description: "Run project discovery workflow" },
+  { name: "context-refresh", queryType: "context_refresh", description: "Run context refresh workflow" },
+  { name: "phase-complete", queryType: "phase_completion", description: "Run phase completion workflow" },
+  { name: "backlog", queryType: "backlog", description: "Open/edit backlog (show routing for backlog)" },
+  // Phase 2 set
+  { name: "plan-create", queryType: "planning", description: "Run planning workflow (create/update plan)" },
+  { name: "dependency-analysis", queryType: "dependency_analysis", description: "Run dependency analysis workflow" },
+  { name: "debt-assessment", queryType: "debt_assessment", description: "Run debt assessment workflow" },
+  // Phase 3 set
+  { name: "docs-update", queryType: "docs_update", description: "Run docs update workflow" },
+  { name: "cross-reference", queryType: "cross_reference", description: "Run cross-reference workflow" },
+];
+
+function outputRouteResult(result, label, asJson) {
+  if (asJson) {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+  console.log(`  Detail — Routing: ${label} (type: ${result.project_type})`);
+  for (const section of ["S1_classify", "S2_select", "S3_resolve", "S4_compute"]) {
+    console.log(`\n  ${section}:`);
+    for (const [k, v] of Object.entries(result[section] || {})) {
+      if (Array.isArray(v)) {
+        console.log(`    ${k}: [${v.join(", ")}]`);
+      } else {
+        console.log(`    ${k}: ${v}`);
+      }
+    }
+  }
+  if (result.S4b_order) {
+    console.log(`\n  S4b_order (dependency-ordered reads):`);
+    for (let i = 0; i < result.S4b_order.ordered_reads.length; i++) {
+      console.log(`    ${i + 1}. ${result.S4b_order.ordered_reads[i]}`);
+    }
+  }
+}
+
+export function register(program) {
+  for (const { name, queryType, description } of ROUTABLE_COMMANDS) {
+    program
+      .command(name)
+      .description(description)
+      .option("-p, --project-type <type>", "Project type: code, context, data, mix, general (auto-detected if omitted)")
+      .option("-s, --stage <stage>", "Workflow stage", "scope")
+      .option("--first-session", "Force WF-04 bootstrap")
+      .option("--registry <path>", "Path to feature-registry.yaml")
+      .option("--json", "Output as JSON")
+      .action(async function () {
+        const opts = this.opts();
+        const { routeByQueryType, detectProjectType } = await getPipeline();
+        const reg = await loadRegistryData(opts.registry);
+
+        let projectType;
+        if (opts.projectType) {
+          projectType = resolveProjectType(opts.projectType);
+        } else {
+          const detected = detectProjectType(".");
+          projectType = detected.project_type || "general";
+        }
+
+        const result = routeByQueryType(
+          queryType,
+          projectType,
+          opts.stage,
+          reg,
+          opts.firstSession || false
+        );
+
+        const docGraph = await loadDocGraph(".");
+        if (docGraph && result.S4_compute?.read_set) {
+          const orderedReads = orderByDependencies(result.S4_compute.read_set, docGraph);
+          result.S4b_order = { ordered_reads: orderedReads, ordering_source: "doc_graph" };
+        }
+
+        if (opts.json) {
+          outputRouteResult(result, `[${queryType}]`, true);
+        } else {
+          const readSet = result.S4b_order?.ordered_reads || result.S4_compute?.read_set || [];
+          const writeSet = result.S4_compute?.write_set || [];
+          const workflowId = result.S2_select?.workflow_id || result.S2_select?.workflow || "—";
+          const summary = [
+            `Workflow ${workflowId}.`,
+            readSet.length ? `Read: ${readSet.slice(0, 5).join(", ")}${readSet.length > 5 ? "…" : ""}.` : "No read set.",
+            writeSet.length ? `Write: ${writeSet.slice(0, 5).join(", ")}${writeSet.length > 5 ? "…" : ""}.` : "No write set.",
+          ].join(" ");
+          const inputRef = `workflow=${queryType}, project type=${projectType}`;
+          printCliReport({ command: name, inputRef, summary });
+          outputRouteResult(result, `[${queryType}]`, false);
+          writeLastRunSummary(".", { command: name, inputRef, summary });
+        }
+      });
+  }
+}

package/lib/cli/route.js

@@ -0,0 +1,101 @@
+/** wwa route — show how a query routes through the pipeline. */
+
+import {
+  resolveProjectType,
+  getPipeline,
+  loadRegistryData,
+} from "./helpers.js";
+import { orderByDependencies } from "../dependencies.js";
+import { loadDocGraph } from "../boundaries.js";
+import { printCliReport, writeLastRunSummary } from "./report-helpers.js";
+
+export function register(program) {
+  program
+    .command("route <query>")
+    .description("Show how a query routes through the pipeline")
+    .option(
+      "-p, --project-type <type>",
+      "Project type: code, context, data, mix, general (auto-detected if omitted)"
+    )
+    .option("-s, --stage <stage>", "Workflow stage", "scope")
+    .option("--first-session", "Force WF-04 bootstrap")
+    .option("--registry <path>", "Path to feature-registry.yaml")
+    .option("--json", "Output as JSON")
+    .action(async (query, opts) => {
+      const { route, detectProjectType } = await getPipeline();
+      const reg = await loadRegistryData(opts.registry);
+
+      let projectType;
+      if (opts.projectType) {
+        projectType = resolveProjectType(opts.projectType);
+      } else {
+        const detected = detectProjectType(".");
+        projectType = detected.project_type || "general";
+      }
+
+      const result = route(
+        query,
+        projectType,
+        opts.stage,
+        reg,
+        opts.firstSession || false
+      );
+
+      // S4b: dependency-ordered reads (optional — requires doc_graph)
+      const docGraph = await loadDocGraph(".");
+      if (docGraph && result.S4_compute?.read_set) {
+        const orderedReads = orderByDependencies(result.S4_compute.read_set, docGraph);
+        result.S4b_order = {
+          ordered_reads: orderedReads,
+          ordering_source: "doc_graph",
+        };
+      }
+
+      if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        const readSet = result.S4b_order?.ordered_reads || result.S4_compute?.read_set || [];
+        const writeSet = result.S4_compute?.write_set || [];
+        const workflowId = result.S2_select?.workflow_id || result.S2_select?.workflow || "—";
+        const summary = [
+          `Query routes to workflow ${workflowId}.`,
+          readSet.length
+            ? `Read these files in order: ${readSet.slice(0, 5).join(", ")}${readSet.length > 5 ? "…" : ""}.`
+            : "No read set.",
+          writeSet.length
+            ? `Write set: ${writeSet.slice(0, 5).join(", ")}${writeSet.length > 5 ? "…" : ""}.`
+            : "No write set.",
+        ].join(" ");
+        const inputRef = `query="${query}", project type=${projectType}`;
+        printCliReport({
+          command: "route",
+          inputRef,
+          summary,
+        });
+        console.log(`  Detail — Routing: "${query}" (type: ${projectType})`);
+        for (const section of [
+          "S1_classify",
+          "S2_select",
+          "S3_resolve",
+          "S4_compute",
+        ]) {
+          console.log(`\n  ${section}:`);
+          for (const [k, v] of Object.entries(result[section])) {
+            if (Array.isArray(v)) {
+              console.log(`    ${k}: [${v.join(", ")}]`);
+            } else {
+              console.log(`    ${k}: ${v}`);
+            }
+          }
+        }
+        if (result.S4b_order) {
+          console.log(`\n  S4b_order (dependency-ordered reads):`);
+          for (let i = 0; i < result.S4b_order.ordered_reads.length; i++) {
+            console.log(`    ${i + 1}. ${result.S4b_order.ordered_reads[i]}`);
+          }
+        }
+        writeLastRunSummary(".", { command: "route", inputRef, summary });
+      }
+    });
+}
+