scrumrun 2.6.5 → 2.6.7

package/README.md

@@ -4,7 +4,7 @@
 
 ScrumRun gives an agent a small command surface and a precise project memory: what should be done, how each attempt happened, which decisions constrain the code, and why the architecture exists in its current form.
 
-**Package:** `2.6.5` · **Method target:** `2.0.0` · **Runtime:** Node.js `>=22.13.0` · **License:** MIT
+**Package:** `2.6.7` · **Method target:** `2.0.0` · **Runtime:** Node.js `>=22.13.0` · **License:** MIT
 
 **New here?** Read the [Quickstart](docs/QUICKSTART.md) — first Run in under 10 minutes, no `SPEC.md` reading required. Full docs map in [`docs/INDEX.md`](docs/INDEX.md).
 

package/lib/commands/repair.js

@@ -26,11 +26,15 @@
 const fs = require("node:fs");
 const path = require("node:path");
 
+const { normalizeLegacyRuns } = require("./normalize-legacy");
+
 const TASK_FILE = /^TASK-\d{3,}\.md$/;
 const RUN_FILE = /^RUN-\d{3,}\.md$/;
 const FEAT_FILE = /^FEAT-\d{3,}\.md$/;
 const SPRINT_FILE = /^SPRINT-\d{3,}\.md$/;
 const MEMORY_FILE = /^(K|DEC|INS|DOS)-\d{3,}\.md$/;
+const TASK_REF = /^TASK-\d{3,}$/;
+const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
 const FEAT_REF = /^FEAT-\d{3,}$/;
 const SLUG_REF = /^[a-z0-9][a-z0-9-]*$/;
 
@@ -47,6 +51,8 @@ const RUN_STATUS_ALIAS = {
   done: "completed"
 };
 
+const GUARDRAIL_SCOPES = new Set(["all", "intake", "execution", "mutation", "canonical", "memory", "migration", "validation", "learning", "completion", "commit", "release", "logs"]);
+
 function readIf(file) {
   try {
     return fs.readFileSync(file, "utf8");
@@ -105,6 +111,19 @@ function planFile(file, kind, ctx) {
   let header = split.header;
   const changes = [];
 
+  const updated = extractField(header, "updated");
+  if (updated !== undefined && updated !== "null" && !ISO_DATE.test(updated)) {
+    const parsed = new Date(updated);
+    if (!isNaN(parsed.getTime())) {
+      const iso = parsed.toISOString().slice(0, 10);
+      const next = replaceField(header, "updated", iso);
+      if (next !== header) {
+        changes.push({ field: "updated", from: updated, to: iso });
+        header = next;
+      }
+    }
+  }
+
   const method = extractField(header, "method");
   if (method === undefined) {
     if (hasField(header, "id")) {
@@ -145,6 +164,22 @@ function planFile(file, kind, ctx) {
   }
 
   if (kind === "run") {
+    const taskRef = extractField(header, "task");
+    if (taskRef === undefined) {
+      if (hasField(header, "id")) {
+        const next = insertFieldAfter(header, "id", "task", "null");
+        if (next !== header) {
+          changes.push({ field: "task", from: "(missing)", to: "null" });
+          header = next;
+        }
+      }
+    } else if (taskRef !== "null" && taskRef !== null && taskRef !== "" && !TASK_REF.test(taskRef)) {
+      const next = replaceField(header, "task", "null");
+      if (next !== header) {
+        changes.push({ field: "task", from: taskRef, to: "null" });
+        header = next;
+      }
+    }
     const status = extractField(header, "status");
     if (status && RUN_STATUS_ALIAS[status]) {
       const next = replaceField(header, "status", RUN_STATUS_ALIAS[status]);
@@ -168,11 +203,32 @@ function planFile(file, kind, ctx) {
   return { file, kind, changes, nextText, originalText: original };
 }
 
+function planGuardrails(scrumDir) {
+  const file = path.join(scrumDir, "guardrails.md");
+  const original = readIf(file);
+  if (original === null) return null;
+  const changes = [];
+  let text = original;
+  const scopeRe = /^(\s*scope:\s*)([^\n\r]+)$/gim;
+  text = text.replace(scopeRe, (match, prefix, value) => {
+    const trimmed = value.trim();
+    if (!trimmed || trimmed === "null") return match;
+    if (GUARDRAIL_SCOPES.has(trimmed)) return match;
+    changes.push({ field: "scope", from: trimmed, to: "all" });
+    return `${prefix}all`;
+  });
+  if (!changes.length) return null;
+  return { file, kind: "guardrails", changes, nextText: text, originalText: original };
+}
+
 function analyze(scrumDir) {
   const featureIds = scanFeatureIds(scrumDir);
   const ctx = { featureIds };
   const entries = [];
 
+  const guardrailPlan = planGuardrails(scrumDir);
+  if (guardrailPlan) entries.push(guardrailPlan);
+
   for (const file of listDir(path.join(scrumDir, "tasks"), TASK_FILE)) {
     const plan = planFile(file, "task", ctx);
     if (plan && plan.changes.length) entries.push(plan);
@@ -217,13 +273,21 @@ function apply(scrumDir, plan) {
     fs.writeFileSync(entry.file, entry.nextText);
     applied.push({ file: relative, backup: path.relative(scrumDir, backupPath), changes: entry.changes });
   }
-  return applied;
+  // Also normalize legacy Run ledgers (empty/broken) — same safety guarantee: byte-exact backup.
+  let ledgerResult = null;
+  try {
+    ledgerResult = normalizeLegacyRuns(scrumDir, { dryRun: false });
+  } catch {
+    ledgerResult = { plan: { malformed: 0 }, applied: [] };
+  }
+  return { applied, ledger: ledgerResult };
 }
 
 function renderReport(plan, applied) {
   const lines = [];
   lines.push("## Repair plan\n");
-  lines.push(`Files needing repair: ${plan.entries.length}`);
+  lines.push(`Files needing frontmatter repair: ${plan.entries.length}`);
+  if (plan.ledgerMalformed) lines.push(`Run ledgers to normalize:        ${plan.ledgerMalformed}`);
   const byField = plan.totals.byField;
   if (Object.keys(byField).length) {
     lines.push("\nBy field:");
@@ -241,7 +305,15 @@ function renderReport(plan, applied) {
   }
   if (applied) {
     lines.push("");
-    lines.push(applied.length ? `Applied: ${applied.length} file(s) rewritten. Backups under .scrumrun/.migration-backup/repair/.` : "Applied: no changes.");
+    const frontmatterCount = applied.applied ? applied.applied.length : 0;
+    const ledgerCount = applied.ledger && applied.ledger.applied ? applied.ledger.applied.length : 0;
+    if (frontmatterCount || ledgerCount) {
+      if (frontmatterCount) lines.push(`Applied: ${frontmatterCount} frontmatter file(s) rewritten.`);
+      if (ledgerCount) lines.push(`Normalized: ${ledgerCount} Run ledger(s) collapsed to snapshot events.`);
+      lines.push("Backups under .scrumrun/.migration-backup/repair/ and .scrumrun/.migration-backup/runs/.");
+    } else {
+      lines.push("Applied: no changes.");
+    }
   } else {
     lines.push("");
     lines.push("The project remains unchanged. Apply with: scrumrun repair --apply");
@@ -254,8 +326,16 @@ function repair(scrumDir, { apply: doApply = false } = {}) {
     throw new Error(".scrumrun/ not found; run this inside a ScrumRun project.");
   }
   const plan = analyze(scrumDir);
+  let ledgerPreview = null;
+  try {
+    ledgerPreview = normalizeLegacyRuns(scrumDir, { dryRun: true }).plan;
+  } catch {
+    ledgerPreview = null;
+  }
+  plan.ledgerMalformed = ledgerPreview ? ledgerPreview.malformed : 0;
   if (!doApply) return { plan, applied: null, report: renderReport(plan, null) };
   const applied = apply(scrumDir, plan);
+  plan.ledgerNormalized = applied.ledger && applied.ledger.applied ? applied.ledger.applied.length : 0;
   return { plan, applied, report: renderReport(plan, applied) };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scrumrun",
-  "version": "2.6.5",
+  "version": "2.6.7",
   "description": "Evidence-driven Agile runtime and semantic project memory for AI coding agents.",
   "bin": {
     "scrumrun": "bin/scrumrun.js",