@ikunin/sprintpilot 2.0.7 → 2.0.8

package/_Sprintpilot/scripts/resolve-dag.js

@@ -64,7 +64,18 @@ function dependenciesPath(projectRoot) {
 }
 
 function parseEpicFromKey(storyKey) {
-  const m = String(storyKey).match(/^(\d+)(?:-|$)/);
+  // Epic id = first hyphen-delimited segment of the story key. BMad's
+  // canonical convention is `<epic-num>-<story-num>-<slug>` (e.g.
+  // `1-2-user-auth` → epic "1"), but nothing prevents a project from
+  // using non-numeric epic identifiers (`auth-1-login`, `infra-bootstrap`).
+  // Pre-2.0.8 this function rejected any non-numeric prefix and returned
+  // null, which silently dropped stories from `--epic` filtering AND let
+  // `infer-dependencies.js` cross-epic edge guards bypass for keys with
+  // no numeric prefix. We now accept any non-empty alphanumeric leading
+  // segment.
+  const s = String(storyKey);
+  if (!s) return null;
+  const m = s.match(/^([A-Za-z0-9]+)(?:-|$)/);
   return m ? m[1] : null;
 }
 
@@ -72,27 +83,42 @@ function readStoriesFromStatus(projectRoot, epicFilter) {
   const file = sprintStatusPath(projectRoot);
   if (!fs.existsSync(file)) return { ordered: [], byKey: {} };
   const raw = fs.readFileSync(file, 'utf8');
-  // Pull out story keys by scanning for two-space-indented `<key>:` lines
-  // under `development_status:` (BMad's canonical shape) and under `stories:`
+  // Pull out story keys by scanning indented `<key>:` lines under
+  // `development_status:` (BMad's canonical shape) and under `stories:`
   // (alternate shape some projects use). We intentionally don't parse the
   // whole YAML — sprint-status is BMad-owned and its schema varies.
+  //
+  // Pre-2.0.8 this hardcoded a 2-space indent. A 4-space or tab-indented
+  // file silently produced zero stories → empty layer → dispatch never
+  // engaged, no warning. Now we detect the FIRST key's indent inside
+  // each stories block and accept only that level (so nested per-story
+  // fields at deeper indents are still correctly excluded).
   const ordered = [];
   const byKey = {};
   const lines = raw.split(/\r?\n/);
   let inStoriesBlock = false;
+  let storyIndent = null;
   for (const rawLine of lines) {
     const trimmed = rawLine.trimEnd();
     if (/^(development_status|stories):\s*$/.test(trimmed)) {
       inStoriesBlock = true;
+      storyIndent = null; // re-detect for each block
       continue;
     }
     // Bail out of the stories block on a top-level key.
-    if (inStoriesBlock && /^\S/.test(trimmed)) inStoriesBlock = false;
+    if (inStoriesBlock && /^\S/.test(trimmed)) {
+      inStoriesBlock = false;
+      storyIndent = null;
+    }
     if (!inStoriesBlock) continue;
-    const m = trimmed.match(/^  ([A-Za-z0-9][A-Za-z0-9-]*):\s*(\S+)?/);
+    const m = trimmed.match(/^([\t ]+)([A-Za-z0-9][A-Za-z0-9-]*):\s*(\S+)?/);
     if (!m) continue;
-    const key = m[1];
-    const status = m[2] ? m[2].replace(/^["']|["']$/g, '') : null;
+    const indent = m[1];
+    const key = m[2];
+    const statusRaw = m[3];
+    if (storyIndent === null) storyIndent = indent;
+    else if (indent !== storyIndent) continue; // nested field at deeper indent
+    const status = statusRaw ? statusRaw.replace(/^["']|["']$/g, '') : null;
     if (epicFilter !== null && parseEpicFromKey(key) !== epicFilter) continue;
     if (!(key in byKey)) {
       ordered.push(key);
@@ -317,7 +343,21 @@ function edgesFromExplicit(depsDoc, nodes) {
     for (const ov of depsDoc.overrides) {
       if (!ov) continue;
       if (Array.isArray(ov.force_sequential)) {
-        const seq = ov.force_sequential.filter((k) => nodeSet.has(k));
+        // Filter to known nodes AND dedupe — a duplicate listing like
+        // `[a, b, a]` would otherwise produce edges `a→b, b→a` (instant
+        // self-cycle) that Kahn's would later reject with an opaque
+        // "cycle detected" error. Reject the typo at the source instead.
+        const seen = new Set();
+        const seq = [];
+        for (const k of ov.force_sequential) {
+          if (!nodeSet.has(k)) continue;
+          if (seen.has(k)) {
+            log.warn(`force_sequential lists '${k}' more than once; ignoring duplicate`);
+            continue;
+          }
+          seen.add(k);
+          seq.push(k);
+        }
         for (let i = 1; i < seq.length; i++) out.push([seq[i - 1], seq[i]]);
       }
     }
@@ -340,7 +380,13 @@ function applyForceIndependent(edges, depsDoc) {
     }
   }
   if (indep.size === 0) return edges;
-  return edges.filter(([a, b]) => !(indep.has(a) || indep.has(b)));
+  // Drop INBOUND edges only — `force_independent: [b]` means "let b run
+  // any time, regardless of its declared deps", not "let everything that
+  // depends on b also run any time". Pre-2.0.8 this stripped both
+  // directions, so a story c with `depends_on: [b]` would lose its edge
+  // and become a free root, then dispatch in the same layer as b — the
+  // exact merge-conflict scenario the override was supposed to control.
+  return edges.filter(([_a, b]) => !indep.has(b));
 }
 
 function buildEdges(strategies, nodes, depsDoc) {

package/_Sprintpilot/scripts/state-shard.js

@@ -87,8 +87,32 @@ function validateKind(k) {
   return { ok: true, value: kind };
 }
 
+// Read BMad's `output_folder` config so a project that customized its
+// output location doesn't end up with shards split between
+// `_bmad-output/` (writer hardcoded) and `<output_folder>/` (reader
+// honoring config). Pre-2.0.8 this script ignored output_folder
+// entirely, contradicting sibling scripts (mark-done-stories-tasks.js)
+// that did read it.
+function readOutputFolder(projectRoot) {
+  const cfg = path.join(projectRoot, '_bmad', 'bmm', 'config.yaml');
+  if (!fs.existsSync(cfg)) return null;
+  try {
+    const body = fs.readFileSync(cfg, 'utf8');
+    const m = body.match(/^output_folder\s*:\s*(\S+)/m);
+    if (!m) return null;
+    return m[1].replace(/^["']|["']$/g, '').trim();
+  } catch {
+    return null;
+  }
+}
+
+function implArtifactsDir(projectRoot) {
+  const folder = readOutputFolder(projectRoot) || '_bmad-output';
+  return path.join(projectRoot, folder, 'implementation-artifacts');
+}
+
 function shardDir(projectRoot, kind) {
-  return path.join(projectRoot, '_bmad-output', 'implementation-artifacts', KIND_DIR[kind]);
+  return path.join(implArtifactsDir(projectRoot), KIND_DIR[kind]);
 }
 
 function shardPath(projectRoot, story, kind) {
@@ -349,7 +373,7 @@ function listShardStories(projectRoot, kind) {
 // --------------------------------------------------------------------------
 
 function pendingDir(projectRoot, kind) {
-  return path.join(projectRoot, '_bmad-output', 'implementation-artifacts', PENDING_DIR, KIND_DIR[kind]);
+  return path.join(implArtifactsDir(projectRoot), PENDING_DIR, KIND_DIR[kind]);
 }
 
 function pendingPath(projectRoot, story, kind) {

package/_Sprintpilot/scripts/summarize-timings.js

@@ -8,11 +8,17 @@
 //
 // Behavior:
 //   Reads every .jsonl file under _bmad-output/implementation-artifacts/
-//   .timings/. Pairs start/end events by (story, phase) in LIFO order.
+//   .timings/. Two event shapes contribute to phase aggregates:
+//     - start/end pairs (matched LIFO by (story, phase))
+//     - duration records emitted by the `mark` API (already-paired)
+//   Records flagged with `clock_skew` or `over_threshold` are excluded
+//   from p50/p95/max so anomalies don't poison the distribution; they
+//   are counted separately in the anomalies section.
 //   Computes:
 //     - Wall-clock per story (min-start to max-end)
 //     - Per-phase aggregates: count, sum_ms, p50, p95, max
 //     - Hotspots: phases whose sum_ms consumes > 5% of total paired time
+//     - Anomalies: per-phase clock_skew / over_threshold counts
 //
 // Output:
 //   --format text (default) → stdout, human-readable table
@@ -82,16 +88,28 @@ function pairEvents(events) {
   // Returns { stories: { [story]: { first, last, phases: { [phase]: number[] } } },
   //           phaseAgg: { [phase]: number[] },
   //           onceCount: { [phase]: number },
+  //           anomalies: { [phase]: { clock_skew: number, over_threshold: number } },
   //           orphans: [{story, phase, event, ts}] }
   const stories = {};
   const phaseAgg = {};
   const onceCount = {};
+  const anomalies = {};
   const openByStoryPhase = {}; // key = story::phase → stack of start ms
 
   const ensureStory = (s) => {
     if (!stories[s]) stories[s] = { first: null, last: null, phases: {} };
     return stories[s];
   };
+  const recordAnomaly = (phase, kind) => {
+    if (!anomalies[phase]) anomalies[phase] = { clock_skew: 0, over_threshold: 0 };
+    anomalies[phase][kind] += 1;
+  };
+  const recordDuration = (s, phase, duration) => {
+    if (!s.phases[phase]) s.phases[phase] = [];
+    s.phases[phase].push(duration);
+    if (!phaseAgg[phase]) phaseAgg[phase] = [];
+    phaseAgg[phase].push(duration);
+  };
 
   for (const ev of events) {
     const s = ensureStory(ev.story);
@@ -114,10 +132,43 @@ function pairEvents(events) {
       const startMs = stack.pop();
       const duration = ev._ms - startMs;
       if (duration < 0) continue;
-      if (!s.phases[ev.phase]) s.phases[ev.phase] = [];
-      s.phases[ev.phase].push(duration);
-      if (!phaseAgg[ev.phase]) phaseAgg[ev.phase] = [];
-      phaseAgg[ev.phase].push(duration);
+      recordDuration(s, ev.phase, duration);
+      continue;
+    }
+    if (ev.event === 'duration') {
+      // mark-API records arrive already paired. Anomalous records
+      // (clock_skew / over_threshold) are tallied separately and never
+      // contribute to p50/p95/max — otherwise a single backstep or
+      // stale marker poisons aggregates the way the v2.0.4 raw clamp
+      // did before the split. duration_ms must be a finite non-negative
+      // number; defensive against hand-edited shards.
+      //
+      // Truthy comparison (not `=== true`) so a hand-edited shard with
+      // `clock_skew: 1` or any other truthy value is still recognized
+      // as an anomaly — symmetric with the defensive number check
+      // below.
+      //
+      // Mutually exclusive tally: per markPhase's contract, one record
+      // can only carry ONE flag (rawDelta is either negative OR exceeds
+      // the ceiling, never both). If a hand-edited shard carries both,
+      // we count clock_skew first since "the clock did something
+      // weird" subsumes "duration looked too long".
+      const skew = Boolean(ev.clock_skew);
+      const over = Boolean(ev.over_threshold);
+      if (skew) recordAnomaly(ev.phase, 'clock_skew');
+      else if (over) recordAnomaly(ev.phase, 'over_threshold');
+      if (skew || over) continue;
+      const d = ev.duration_ms;
+      if (typeof d !== 'number' || !Number.isFinite(d) || d < 0) continue;
+      // Wall-clock attribution: a duration record's `_ms` is the time
+      // the phase ENDED (when markPhase emitted the record). To make
+      // per-story `wall_ms` meaningful for mark-only stories, expand
+      // `s.first` backward by the recorded duration so `first` reflects
+      // the actual phase start. Without this, a story with a single
+      // mark record has `wall_ms = 0`.
+      const phaseStart = ev._ms - d;
+      if (s.first === null || phaseStart < s.first) s.first = phaseStart;
+      recordDuration(s, ev.phase, d);
     }
   }
 
@@ -129,7 +180,7 @@ function pairEvents(events) {
     }
   }
 
-  return { stories, phaseAgg, onceCount, orphans };
+  return { stories, phaseAgg, onceCount, anomalies, orphans };
 }
 
 function percentile(sorted, p) {
@@ -177,6 +228,7 @@ function aggregate(paired) {
     hotspots,
     stories,
     once_markers: paired.onceCount,
+    anomalies: paired.anomalies,
     orphans: paired.orphans,
   };
 }
@@ -234,6 +286,17 @@ function renderText(report) {
       lines.push(`  ${phase}  ×${count}`);
     }
   }
+  const anomalyEntries = Object.entries(report.anomalies || {});
+  if (anomalyEntries.length > 0) {
+    lines.push('');
+    lines.push('Anomalies (excluded from p50/p95/max):');
+    for (const [phase, counts] of anomalyEntries) {
+      const parts = [];
+      if (counts.clock_skew > 0) parts.push(`clock_skew ×${counts.clock_skew}`);
+      if (counts.over_threshold > 0) parts.push(`over_threshold ×${counts.over_threshold}`);
+      lines.push(`  ${phase}  ${parts.join('  ')}`);
+    }
+  }
   if (report.orphans.length > 0) {
     lines.push('');
     lines.push(`Orphaned starts (no matching end): ${report.orphans.length}`);
@@ -290,6 +353,21 @@ function renderMarkdown(report) {
       lines.push(`- \`${phase}\` ×${count}`);
     }
   }
+  const mdAnomalyEntries = Object.entries(report.anomalies || {}).filter(
+    ([, c]) => c.clock_skew > 0 || c.over_threshold > 0,
+  );
+  if (mdAnomalyEntries.length > 0) {
+    lines.push('');
+    lines.push('## Anomalies');
+    lines.push('');
+    lines.push('_Excluded from p50/p95/max so a single skew/stale-marker doesn\'t poison aggregates._');
+    lines.push('');
+    lines.push('| Phase | clock_skew | over_threshold |');
+    lines.push('|---|---:|---:|');
+    for (const [phase, counts] of mdAnomalyEntries) {
+      lines.push(`| \`${phase}\` | ${counts.clock_skew} | ${counts.over_threshold} |`);
+    }
+  }
   if (report.orphans.length > 0) {
     lines.push('');
     lines.push(`_Orphaned starts (no matching end): ${report.orphans.length}_`);