@hjr15/blaze-board 0.2.0

package/scripts/migrate/merge.mjs

@@ -0,0 +1,103 @@
+// scripts/migrate/merge.mjs — pure: fold approved merges. For each ledger
+// `merge-into:A` on B, the survivor A absorbs B's worklog + typed links + any
+// unique AC, plus a `Duplicate` breadcrumb pointing at B. B is folded away (logged,
+// not written). Survivors excludes dropped + merged-away keys.
+const AC_HEADING = "## Acceptance Criteria";
+
+export function extractAC(description) {
+  const lines = String(description ?? "").split("\n");
+  const out = [];
+  let inAC = false;
+  for (const line of lines) {
+    if (line.trim() === AC_HEADING) { inAC = true; continue; }
+    if (inAC && /^##\s/.test(line.trim())) break;
+    if (inAC && /^\s*-\s*\[.?\]/.test(line)) out.push(line.trim());
+  }
+  return out;
+}
+
+function appendAC(description, acLines) {
+  if (acLines.length === 0) return description;
+  const existing = new Set(extractAC(description).map((s) => s.replace(/\[.?\]/, "[ ]")));
+  const fresh = acLines.filter((s) => !existing.has(s.replace(/\[.?\]/, "[ ]")));
+  if (fresh.length === 0) return description;
+  if (!description.includes(AC_HEADING)) return `${description}\n\n${AC_HEADING}\n${fresh.join("\n")}\n`;
+  // Insert after the AC heading line.
+  const lines = description.split("\n");
+  const idx = lines.findIndex((l) => l.trim() === AC_HEADING);
+  lines.splice(idx + 1, 0, ...fresh);
+  return lines.join("\n");
+}
+
+export function foldMerges(byKey, dispositions) {
+  const dispById = new Map(dispositions.map((d) => [d.id, d.disposition]));
+  const folded = new Set();
+  const survivors = new Map();
+
+  // Seed survivors with kept/re-parented items (clone so we can mutate safely).
+  for (const [key, issue] of byKey) {
+    const d = dispById.get(key) || "keep";
+    if (d === "drop" || d.startsWith("merge-into:")) continue;
+    survivors.set(key, { ...issue, worklog: [...(issue.worklog || [])], links: [...(issue.links || [])] });
+  }
+
+  for (const disp of dispositions) {
+    if (!disp.disposition.startsWith("merge-into:")) continue;
+    const survivorKey = disp.disposition.slice("merge-into:".length);
+    const loser = byKey.get(disp.id);
+    const survivor = survivors.get(survivorKey);
+    folded.add(disp.id);
+    if (!loser || !survivor) continue;
+    survivor.worklog.push(...(loser.worklog || []));
+    for (const l of loser.links || []) {
+      // FIX 1: skip any link from the loser whose target is the survivor itself (self-link guard)
+      if (l.target === survivorKey) continue;
+      if (!survivor.links.some((x) => x.type === l.type && x.target === l.target)) survivor.links.push(l);
+    }
+    if (!survivor.links.some((x) => x.type === "Duplicate" && x.target === disp.id)) {
+      survivor.links.push({ type: "Duplicate", target: disp.id });
+    }
+    survivor.description = appendAC(survivor.description, extractAC(loser.description));
+  }
+  return { survivors, folded };
+}
+
+// FIX 2: resolve a survivor set's links against the final written-id set:
+//  - rewrite a NON-Duplicate link whose target is a merged-away loser → that loser's survivor
+//  - drop a NON-Duplicate link whose (post-rewrite) target is the survivor's own id (self-link)
+//  - drop a NON-Duplicate link whose (post-rewrite) target is not in the written-id set (dangling)
+//  - dedup links by type+target
+// `Duplicate` links are EXEMPT (they are intentional breadcrumbs that may reference a
+// merged-away / dropped id). Pure; returns cleaned survivors + an integrity report.
+export function resolveLinkIntegrity(survivors, dispositions) {
+  const mergeMap = new Map();
+  for (const d of dispositions) {
+    if (typeof d.disposition === "string" && d.disposition.startsWith("merge-into:")) {
+      mergeMap.set(d.id, d.disposition.slice("merge-into:".length));
+    }
+  }
+  const writtenIds = new Set(survivors.keys());
+  const rewritten = [], dropped = [];
+  const out = new Map();
+  for (const [key, issue] of survivors) {
+    const seen = new Set();
+    const cleaned = [];
+    for (const link of issue.links || []) {
+      if (link.type === "Duplicate") { // breadcrumb — keep as-is (deduped)
+        const sig = `Duplicate::${link.target}`;
+        if (!seen.has(sig)) { seen.add(sig); cleaned.push({ type: link.type, target: link.target }); }
+        continue;
+      }
+      let target = link.target;
+      if (mergeMap.has(target)) { rewritten.push({ on: key, from: target, to: mergeMap.get(target), type: link.type }); target = mergeMap.get(target); }
+      if (target === key) { dropped.push({ on: key, target, type: link.type, reason: "self-link" }); continue; }
+      if (!writtenIds.has(target)) { dropped.push({ on: key, target, type: link.type, reason: "target not written" }); continue; }
+      const sig = `${link.type}::${target}`;
+      if (seen.has(sig)) continue;
+      seen.add(sig);
+      cleaned.push({ type: link.type, target });
+    }
+    out.set(key, { ...issue, links: cleaned });
+  }
+  return { survivors: out, integrity: { rewritten, dropped } };
+}

package/scripts/migrate/normalize.mjs

@@ -0,0 +1,60 @@
+// scripts/migrate/normalize.mjs — pure: raw Jira-Cloud issue JSON → NormalizedIssue.
+// Quarantines the raw payload shape so the downstream cores work on a stable shape.
+// CUSTOM_FIELDS holds Risk custom-field IDs — real IDs discovered from a live
+// payload at build time and edited here (placeholders until then).
+export const CUSTOM_FIELDS = { likelihood: "customfield_10040", impact: "customfield_10004" };
+
+// Best-effort ADF → text. A string passes through; null → "".
+export function adfToText(node) {
+  if (node == null) return "";
+  if (typeof node === "string") return node;
+  let out = "";
+  if (node.text) out += node.text;
+  if (Array.isArray(node.content)) {
+    for (const child of node.content) out += adfToText(child);
+    if (node.type === "paragraph" || node.type === "heading") out += "\n";
+  }
+  return out;
+}
+
+function dateOnly(s) { return s ? String(s).slice(0, 10) : null; }
+function fieldVal(v) { return v == null ? null : (typeof v === "object" ? (v.value ?? v.name ?? null) : v); }
+// Worklog notes are stored as a single-line frontmatter inline-object value, so
+// collapse any newlines (a multi-line value would break the YAML-subset re-parse).
+function cleanNote(s) { if (!s) return null; const t = String(s).replace(/\s*\n\s*/g, " ").trim(); return t || null; }
+
+export function normalizeIssue(raw, fields = CUSTOM_FIELDS) {
+  const f = raw.fields || {};
+  const worklogs = (f.worklog && f.worklog.worklogs) || [];
+  const links = [];
+  for (const l of f.issuelinks || []) {
+    const other = l.outwardIssue || l.inwardIssue;
+    if (l.type && l.type.name && other && other.key) links.push({ type: l.type.name, target: other.key });
+  }
+  return {
+    key: raw.key,
+    project: (f.project && f.project.key) || (raw.key ? String(raw.key).split("-")[0] : null),
+    type: (f.issuetype && f.issuetype.name) || null,
+    summary: f.summary || "",
+    description: adfToText(f.description),
+    status: (f.status && f.status.name) || null,
+    statusCategory: (f.status && f.status.statusCategory && f.status.statusCategory.key) || null,
+    resolution: (f.resolution && f.resolution.name) || null,
+    priority: (f.priority && f.priority.name) || null,
+    assignee: (f.assignee && f.assignee.displayName) || null,
+    labels: f.labels || [],
+    components: (f.components || []).map((c) => c.name),
+    parent: (f.parent && f.parent.key) || null,
+    estimateSeconds: typeof f.timeoriginalestimate === "number" ? f.timeoriginalestimate : null,
+    worklog: worklogs.map((w) => ({
+      date: dateOnly(w.started), seconds: w.timeSpentSeconds || 0,
+      author: (w.author && w.author.displayName) || null,
+      note: cleanNote(typeof w.comment === "string" ? w.comment : adfToText(w.comment)),
+    })),
+    links,
+    likelihood: fieldVal(f[fields.likelihood]),
+    impact: fieldVal(f[fields.impact]),
+    created: dateOnly(f.created),
+    updated: dateOnly(f.updated),
+  };
+}

package/scripts/migrate/report.mjs

@@ -0,0 +1,67 @@
+// scripts/migrate/report.mjs — pure: render the human-readable MIGRATION-AUDIT.md
+// and the disposition-ledger object. The report is the reviewable proposal; the
+// ledger is the editable, authoritative sign-off artifact.
+export function renderLedger(dispositions, source) {
+  return { source, items: dispositions };
+}
+
+function countByProjectType(norms) {
+  const m = {};
+  for (const n of norms) {
+    m[n.project] ??= {};
+    m[n.project][n.type] = (m[n.project][n.type] || 0) + 1;
+  }
+  return m;
+}
+
+export function renderAudit({ norms, dispositions, restructure, warnings = [], integrity = { rewritten: [], dropped: [] } }) {
+  const drops = dispositions.filter((d) => d.disposition === "drop");
+  const merges = dispositions.filter((d) => d.disposition.startsWith("merge-into:"));
+  const keeps = dispositions.filter((d) => d.disposition === "keep" || d.disposition.startsWith("re-parent:"));
+  const counts = countByProjectType(norms);
+
+  const out = [];
+  out.push("# Migration Audit", "");
+  out.push(`**Source:** ${norms.length} issues · **kept:** ${keeps.length} · **dropped:** ${drops.length} · **merged:** ${merges.length}`, "");
+
+  out.push("## Counts (per project × type)", "");
+  for (const project of Object.keys(counts).sort()) {
+    out.push(`### ${project}`);
+    for (const type of Object.keys(counts[project]).sort()) out.push(`- ${type}: ${counts[project][type]}`);
+    out.push("");
+  }
+
+  out.push("## Dropped (non-Done terminal — NOT written)", "");
+  if (drops.length === 0) out.push("_none_", "");
+  for (const d of drops) out.push(`- ${d.id} — ${d.reason}`);
+  out.push("");
+
+  out.push("## Merge candidates (folded into survivor — NOT written)", "");
+  if (merges.length === 0) out.push("_none_", "");
+  for (const d of merges) out.push(`- ${d.id} → ${d.disposition.slice("merge-into:".length)} (${d.reason})`);
+  out.push("");
+
+  out.push("## Restructure flags", "");
+  const f = restructure.flags;
+  out.push(`- orphans: ${f.orphans.join(", ") || "_none_"}`);
+  out.push(`- mis-levelled: ${f.misLevelled.join(", ") || "_none_"}`);
+  out.push(`- ambiguous parent: ${f.ambiguous.join(", ") || "_none_"}`);
+  out.push(`- Relates→parent normalised: ${f.relatesNormalised.join(", ") || "_none_"}`, "");
+
+  out.push("## Warnings (unmapped / validation — review)", "");
+  if (warnings.length === 0) out.push("_none_", "");
+  for (const w of warnings) out.push(`- ${w}`);
+  out.push("");
+
+  out.push("## Link integrity", "");
+  if (integrity.rewritten.length === 0 && integrity.dropped.length === 0) {
+    out.push("_none_", "");
+  } else {
+    for (const r of integrity.rewritten) out.push(`- ${r.on}: ${r.type} ${r.from} → ${r.to}`);
+    for (const d of integrity.dropped) out.push(`- ${d.on}: dropped ${d.type} → ${d.target} (${d.reason})`);
+    out.push("");
+  }
+
+  out.push("---", "_Edit `migration/disposition-ledger.json` to override any disposition, then run `blaze migrate --live`._");
+  return out.join("\n");
+}

package/scripts/migrate/restructure.mjs

@@ -0,0 +1,49 @@
+// scripts/migrate/restructure.mjs — pure: propose a coherent Goal/Epic hierarchy.
+// Keeps legal native parents; normalises the free-tier Goal↔Epic Relates-link
+// workaround (used when a paid Jira tier's native Epic-link isn't available)
+// into a native parent; flags orphans / mis-levelled / ambiguous items.
+// Output feeds the ledger's proposed_parent (the user signs off).
+import { canParent, isType } from "../model/schema.mjs";
+import { mapType } from "./map.mjs";
+
+export function proposeStructure(norms) {
+  const byKey = new Map(norms.map((n) => [n.key, n]));
+  const typeOf = (key) => { const n = byKey.get(key); return n ? mapType(n.type) : null; };
+
+  const parents = new Map();
+  const flags = { orphans: [], misLevelled: [], ambiguous: [], relatesNormalised: [] };
+
+  for (const n of norms) {
+    const childType = mapType(n.type);
+    if (!isType(childType)) { parents.set(n.key, null); continue; }
+
+    // 1) Native parent, if legal.
+    if (n.parent) {
+      const pt = typeOf(n.parent);
+      if (pt && canParent(childType, pt)) { parents.set(n.key, n.parent); continue; }
+      if (pt) { parents.set(n.key, null); flags.misLevelled.push(n.key); continue; }
+      // unknown native parent key → fall through to Relates / orphan handling
+    }
+
+    // 2) Relates-link candidates whose type is a legal parent.
+    const candidates = (n.links || [])
+      .filter((l) => l.type === "Relates")
+      .map((l) => l.target)
+      .filter((k) => { const pt = typeOf(k); return pt && canParent(childType, pt); });
+
+    if (candidates.length === 1) {
+      parents.set(n.key, candidates[0]);
+      flags.relatesNormalised.push(n.key);
+      continue;
+    }
+    if (candidates.length > 1) { parents.set(n.key, null); flags.ambiguous.push(n.key); continue; }
+
+    // 3) No resolved parent. Orphan only if this type expects one. Goals are
+    // top-level; Risks may parent to goal/epic but are allowed top-level here →
+    // neither is orphaned for "no parent".
+    parents.set(n.key, null);
+    const needsParent = ["epic", "story", "task", "bug", "subtask"].includes(childType);
+    if (needsParent) flags.orphans.push(n.key);
+  }
+  return { parents, flags };
+}

package/scripts/migrate-runner.mjs

@@ -0,0 +1,51 @@
+// scripts/migrate-runner.mjs — CLI entry for `blaze migrate`. Dry-run (default)
+// runs the audit pipeline over .migration-cache/ and writes migration/MIGRATION-
+// AUDIT.md + migration/disposition-ledger.json. The MCP pull that populates the
+// cache is performed by the jira-export-migrator agent, not this script.
+import { writeFileSync, mkdirSync, readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { spawnSync } from "node:child_process";
+import { runDryRun, runLive } from "./migrate/jira-import.mjs";
+import { resolveRoots, loadConfig } from "./config.mjs";
+
+const { dataRoot, projectsDir } = resolveRoots();
+const CACHE = join(dataRoot, ".migration-cache");
+const MIGRATION = join(dataRoot, "migration");
+
+const argv = process.argv.slice(2);
+const mode = argv.includes("--live") ? "live" : "dry-run";
+const projIdx = argv.indexOf("--project");
+if (projIdx !== -1 && argv[projIdx + 1] === undefined) {
+  console.error("usage: blaze migrate [--dry-run|--live] [--project KEY] [--merge]");
+  process.exit(1);
+}
+// No explicit --project: fall back to blaze.config.json's configured projects
+// list rather than a hardcoded guess.
+const configuredKeys = loadConfig({ root: dataRoot }).projects;
+const keys = projIdx !== -1 ? [argv[projIdx + 1]] : configuredKeys;
+if (keys.length === 0) {
+  console.error("usage: blaze migrate [--dry-run|--live] --project KEY [--merge] (no projects configured in blaze.config.json)");
+  process.exit(1);
+}
+const enableMerges = argv.includes("--merge");
+
+if (mode === "dry-run") {
+  const { auditMd, ledger, stats } = runDryRun({ cacheDir: CACHE, keys, detectMerges: enableMerges });
+  mkdirSync(MIGRATION, { recursive: true });
+  ledger.generated = new Date().toISOString().slice(0, 10);
+  writeFileSync(join(MIGRATION, "MIGRATION-AUDIT.md"), auditMd);
+  writeFileSync(join(MIGRATION, "disposition-ledger.json"), JSON.stringify(ledger, null, 2) + "\n");
+  console.log(`dry-run: source ${stats.source} · kept ${stats.kept} · dropped ${stats.dropped} · merged ${stats.merged}`);
+  console.log(`wrote migration/MIGRATION-AUDIT.md + migration/disposition-ledger.json — review + edit, then: blaze migrate --live`);
+} else {
+  const ledgerPath = join(MIGRATION, "disposition-ledger.json");
+  if (!existsSync(ledgerPath)) {
+    console.error(`refusing --live: ${ledgerPath} not found. Run a --dry-run, review + edit the ledger first.`);
+    process.exit(1);
+  }
+  const ledger = JSON.parse(readFileSync(ledgerPath, "utf8"));
+  const res = runLive({ cacheDir: CACHE, projectsDir, keys, ledger });
+  spawnSync("git", ["-C", dataRoot, "add", "-A"], { stdio: "ignore" });
+  spawnSync("git", ["-C", dataRoot, "commit", "-m", `migrate: import ${keys.join("+")} from Jira (${res.written.length} tickets)`], { stdio: "inherit" });
+  console.log(`live: wrote ${res.written.length} tickets · dropped ${res.dropped} · merged ${res.merged}`);
+}

package/scripts/model/ids.mjs

@@ -0,0 +1,32 @@
+// scripts/model/ids.mjs — per-project sequential ID allocation by filesystem
+// scan. Zero stored state: the highest <KEY>-N on disk (closed tickets stay in
+// terminal dirs, so the high-water mark survives) + 1. (Phase-3 design §1.2.)
+import { readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+
+function* walkFiles(dir) {
+  let entries = [];
+  try { entries = readdirSync(dir); } catch { return; }
+  for (const e of entries) {
+    const p = join(dir, e);
+    let s;
+    try { s = statSync(p); } catch { continue; }
+    if (s.isDirectory()) yield* walkFiles(p);
+    else yield p;
+  }
+}
+
+export function maxId(projectsDir, key) {
+  const re = new RegExp("(?:^|[/\\\\])" + key + "-(\\d+)\\b", "i");
+  let max = 0;
+  for (const f of walkFiles(join(projectsDir, key))) {
+    if (!f.endsWith(".md")) continue;
+    const m = re.exec(f);
+    if (m) max = Math.max(max, Number(m[1]));
+  }
+  return max;
+}
+
+export function nextId(projectsDir, key) {
+  return `${key}-${maxId(projectsDir, key) + 1}`;
+}

package/scripts/model/index.mjs

@@ -0,0 +1,63 @@
+// scripts/model/index.mjs — build a queryable read model from all ticket files
+// across all projects. The index is DISPOSABLE: rebuild any time from markdown
+// (the source of truth). Pure-JS / zero-dep so it runs on blaze's Node floor.
+// The Index interface is storage-agnostic — a future node:sqlite implementation
+// must satisfy the same shape (spec §13, revised), so the swap stays contained.
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { parseTicket } from "./ticket.mjs";
+
+function safeReaddir(p) { try { return readdirSync(p); } catch { return []; } }
+function isDir(p) { try { return statSync(p).isDirectory(); } catch { return false; } }
+
+// Yields every ticket under projectsDir/<KEY>/<status>/<id>.md
+export function* walkTickets(projectsDir) {
+  for (const project of safeReaddir(projectsDir)) {
+    const projPath = join(projectsDir, project);
+    if (!isDir(projPath)) continue;
+    for (const status of safeReaddir(projPath)) {
+      const statusPath = join(projPath, status);
+      if (!isDir(statusPath)) continue;
+      for (const f of safeReaddir(statusPath)) {
+        if (!f.endsWith(".md")) continue;
+        const file = join(statusPath, f);
+        const { frontmatter, body } = parseTicket(readFileSync(file, "utf8"));
+        yield { frontmatter, body, status, file };
+      }
+    }
+  }
+}
+
+function makeIndex(rows, links) {
+  const byId = new Map(rows.map((r) => [r.id, r]));
+  return {
+    rows,
+    links,
+    get: (id) => byId.get(id),
+    count: () => rows.length,
+    byProject: (project) => rows.filter((r) => r.project === project),
+    countByProject: () => rows.reduce((acc, r) => {
+      acc[r.project] = (acc[r.project] || 0) + 1; return acc;
+    }, {}),
+    linksFrom: (id) => links.filter((l) => l.src === id),
+    toJSON: () => ({ tickets: rows, links }),
+  };
+}
+
+export function buildIndex(projectsDir) {
+  const rows = [];
+  const links = [];
+  for (const t of walkTickets(projectsDir)) {
+    const fm = t.frontmatter;
+    const worklog_minutes = Array.isArray(fm.worklog)
+      ? fm.worklog.reduce((s, w) => s + (Number(w.minutes) || 0), 0) : 0;
+    rows.push({
+      id: fm.id, project: fm.project ?? null, type: fm.type ?? null, title: fm.title ?? null,
+      status: t.status, priority: fm.priority ?? null, resolution: fm.resolution ?? null,
+      parent: fm.parent ?? null, assignee: fm.assignee ?? null, estimate: fm.estimate ?? null,
+      worklog_minutes, file: t.file,
+    });
+    for (const link of fm.links ?? []) links.push({ src: fm.id, type: link.type, target: link.target });
+  }
+  return makeIndex(rows, links);
+}

package/scripts/model/move-plan.mjs

@@ -0,0 +1,25 @@
+// scripts/model/move-plan.mjs — pure planner for a status move: validate the
+// transition, apply the optional worklog-before-terminal guard, and compute the
+// new frontmatter with resolution set/cleared by the post-function. No I/O.
+import { validateTransition } from "./rules.mjs";
+import { isTerminal, resolutionForTerminal } from "./workflows.mjs";
+import { hierarchyLevel } from "./schema.mjs";
+
+export function planMove(ticket, currentStatus, toStatus, opts = {}) {
+  const { hasWorklog = true, requireWorklog = false } = opts;
+  const type = ticket.frontmatter.type;
+  const errors = validateTransition(type, currentStatus, toStatus);
+  // The worklog-before-terminal guard applies to LEAF work items only
+  // (story/task/bug/subtask, hierarchyLevel <= 0). Epics/goals/risks aggregate —
+  // their time rolls up from children, so they carry no direct worklog and must
+  // not be blocked from reaching a terminal status.
+  const enforceWorklog = requireWorklog && hierarchyLevel(type) <= 0;
+  if (errors.length === 0 && enforceWorklog && isTerminal(type, toStatus) && !hasWorklog) {
+    errors.push(`worklog required before entering terminal status ${toStatus}`);
+  }
+  if (errors.length) return { ok: false, errors };
+
+  const frontmatter = { ...ticket.frontmatter };
+  frontmatter.resolution = isTerminal(type, toStatus) ? resolutionForTerminal(type, toStatus) : null;
+  return { ok: true, errors: [], frontmatter, body: ticket.body, resolution: frontmatter.resolution };
+}

package/scripts/model/rollup.mjs

@@ -0,0 +1,55 @@
+// scripts/model/rollup.mjs — derived time roll-up over the index. Pure; reads
+// only index.rows. buildIndex stays leaf-only (the storage-agnostic seam); the
+// roll-up is computed on top. (Spec §2/§3.)
+//
+//   rolled(node) = node.own + Σ rolled(child)   over the transitive subtree
+//
+// own_* is kept separate from rolled_*. Cycle-guarded (a per-traversal visited
+// set), orphan-parent rows are roots, null estimate contributes 0.
+
+export function rollUp(index) {
+  const rows = index.rows || [];
+  const own = new Map();        // id → { est, log }
+  const children = new Map();   // parentId → id[]
+  for (const r of rows) {
+    own.set(r.id, { est: Number(r.estimate) || 0, log: Number(r.worklog_minutes) || 0 });
+  }
+  for (const r of rows) {
+    // Only treat parent as an edge when it resolves to a known row; otherwise
+    // the row is a root (orphan parent).
+    if (r.parent && own.has(r.parent)) {
+      if (!children.has(r.parent)) children.set(r.parent, []);
+      children.get(r.parent).push(r.id);
+    }
+  }
+
+  // Subtree sum from `start`, guarded so a malformed cycle terminates and no node
+  // is counted twice within one traversal.
+  function subtree(start) {
+    let est = 0, log = 0, count = -1; // -1 so `start` itself isn't a descendant
+    const visited = new Set();
+    const stack = [start];
+    while (stack.length) {
+      const id = stack.pop();
+      if (visited.has(id)) continue;
+      visited.add(id);
+      const o = own.get(id);
+      if (o) { est += o.est; log += o.log; }
+      count++;
+      for (const c of children.get(id) || []) if (!visited.has(c)) stack.push(c);
+    }
+    return { est, log, count };
+  }
+
+  const result = new Map();
+  for (const r of rows) {
+    const o = own.get(r.id);
+    const s = subtree(r.id);
+    result.set(r.id, {
+      own_estimate: o.est, own_worklog: o.log,
+      rolled_estimate: s.est, rolled_worklog: s.log,
+      descendant_count: s.count,
+    });
+  }
+  return result;
+}

package/scripts/model/rules.mjs

@@ -0,0 +1,64 @@
+// scripts/model/rules.mjs — the single home for Blaze business rules.
+// Phase 1: required-field + parent-integrity validation. (Transitions: Phase 2.)
+import { isType, requiredFields, canParent, PRIORITIES } from "./schema.mjs";
+import { statusesFor, canTransition, RESOLUTIONS } from "./workflows.mjs";
+
+// ticket = { frontmatter, body }; lookup(id) => ticket | null (for parent checks).
+export function validateTicket(ticket, lookup = () => null) {
+  const errors = [];
+  const fm = ticket.frontmatter || {};
+  const type = fm.type;
+
+  if (!isType(type)) {
+    errors.push(`unknown or missing type: ${type}`);
+    return errors;
+  }
+
+  for (const field of requiredFields(type)) {
+    if (field === "description") {
+      if (!ticket.body || ticket.body.trim() === "") errors.push("missing required: description (body)");
+    } else if (fm[field] === undefined || fm[field] === null || fm[field] === "") {
+      errors.push(`missing required: ${field}`);
+    }
+  }
+
+  // Enum validation for priority and resolution.
+  if (fm.priority && !PRIORITIES.includes(fm.priority)) {
+    errors.push(`invalid priority: ${fm.priority}`);
+  }
+  if (fm.resolution && !RESOLUTIONS.includes(fm.resolution)) {
+    errors.push(`invalid resolution: ${fm.resolution}`);
+  }
+
+  if (fm.parent) {
+    const parent = lookup(fm.parent);
+    if (!parent) {
+      errors.push(`parent not found: ${fm.parent}`);
+    } else {
+      if (!canParent(type, parent.frontmatter.type)) {
+        errors.push(`invalid parent: ${type} cannot be a child of ${parent.frontmatter.type}`);
+      }
+      const seen = new Set([fm.id]);
+      let cur = parent;
+      while (cur && cur.frontmatter.parent) {
+        if (seen.has(cur.frontmatter.id)) { errors.push(`parent cycle detected at ${cur.frontmatter.id}`); break; }
+        seen.add(cur.frontmatter.id);
+        cur = lookup(cur.frontmatter.parent);
+      }
+    }
+  }
+  return errors;
+}
+
+// Type-scoped transition validation. Separate from resolution (which is a post-
+// function, not a transition gate). Returns [] when the move is legal.
+export function validateTransition(type, from, to) {
+  const errors = [];
+  if (!isType(type)) { errors.push(`unknown type: ${type}`); return errors; }
+  if (!statusesFor(type).includes(to)) {
+    errors.push(`invalid status '${to}' for type ${type}`);
+  } else if (!canTransition(type, from, to)) {
+    errors.push(`illegal transition: ${from} → ${to} for type ${type}`);
+  }
+  return errors;
+}

package/scripts/model/schema.mjs

@@ -0,0 +1,30 @@
+// scripts/model/schema.mjs — Blaze type registry: hierarchy, parent rules,
+// required fields, and the workflow that governs each type. Pure data + helpers.
+
+/** Canonical priority enum — single source of truth across rules, serve, and client. */
+export const PRIORITIES = ["highest", "high", "medium", "low", "lowest", "none", "urgent"];
+
+export const TYPES = {
+  goal:    { level: 2,  workflow: "goal",     parentTypes: [],                       required: ["title", "description"] },
+  epic:    { level: 1,  workflow: "delivery", parentTypes: ["goal"],                 required: ["title", "description"] },
+  risk:    { level: 1,  workflow: "risk",     parentTypes: ["goal", "epic"],         required: ["title", "description", "likelihood", "impact"] },
+  story:   { level: 0,  workflow: "delivery", parentTypes: ["epic"],                 required: ["title", "description", "estimate"] },
+  task:    { level: 0,  workflow: "delivery", parentTypes: ["epic"],                 required: ["title", "description", "estimate"] },
+  bug:     { level: 0,  workflow: "delivery", parentTypes: ["epic"],                 required: ["title", "description", "estimate"] },
+  subtask: { level: -1, workflow: "delivery", parentTypes: ["story", "task", "bug"], required: ["title", "description"] },
+};
+
+export function allTypes() { return Object.keys(TYPES); }
+
+export function isType(t) { return Object.prototype.hasOwnProperty.call(TYPES, t); }
+
+function must(type) { if (!isType(type)) throw new Error(`unknown type: ${type}`); }
+
+export function hierarchyLevel(type) { must(type); return TYPES[type].level; }
+export function workflowFor(type)    { must(type); return TYPES[type].workflow; }
+export function requiredFields(type) { must(type); return TYPES[type].required; }
+
+export function canParent(childType, parentType) {
+  must(childType); must(parentType);
+  return TYPES[childType].parentTypes.includes(parentType);
+}