@ikunin/sprintpilot 2.2.28 → 2.2.30

package/_Sprintpilot/bin/autopilot.js

@@ -1380,18 +1380,66 @@ function cmdStart(opts) {
   }
 
   // Resume detection: if a prior session left a fingerprint, diff.
+  // Two escape hatches let cmdStart proceed despite a divergent fingerprint:
+  //
+  //   1. External completion (auto): if the last halt's `current_story`
+  //      is now marked `done` in sprint-status, the divergence is the
+  //      EXPECTED result of completing that story outside the autopilot
+  //      (manual merge, hot-fix, PR landed via the UI). Clear the
+  //      stale story identity from persisted state and proceed —
+  //      composeRuntimeState's resolver will pick the next pending story.
+  //
+  //   2. Explicit --accept-divergence flag: catch-all for cases (1) doesn't
+  //      cover (multiple stories completed, branch heads moved, etc.). The
+  //      flag is logged into the ledger so the audit trail records that
+  //      the user opted in to bypass.
   const lastHalt = ledger.last({ projectRoot }, 'halt');
   if (lastHalt && lastHalt.fingerprint) {
     const d = divergence.detect({ projectRoot }, lastHalt.fingerprint);
     if (!d.identical) {
-      const result = {
-        kind: 'resume_divergence',
-        differences: d.differences,
-        last_phase: persisted.current_bmad_step || null,
-      };
-      ledger.append({ kind: 'resume', divergence: result }, { projectRoot });
-      process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
-      return 0;
+      let autoAck = null;
+      const persistedStory = persisted.current_story || null;
+      if (persistedStory) {
+        const stories = readSprintStatuses(projectRoot);
+        const status = stories && stories[persistedStory]
+          ? String(stories[persistedStory].status || '').trim().toLowerCase()
+          : null;
+        if (status === 'done') {
+          autoAck = { reason: 'external_completion', story: persistedStory };
+        }
+      }
+      const accepted = autoAck || (opts['accept-divergence'] ? { reason: 'explicit_accept' } : null);
+      if (!accepted) {
+        const result = {
+          kind: 'resume_divergence',
+          differences: d.differences,
+          last_phase: persisted.current_bmad_step || null,
+          hint:
+            'Pass --accept-divergence to proceed despite the diff, or finish externally-merged stories so sprint-status reflects reality before resuming.',
+        };
+        ledger.append({ kind: 'resume', divergence: result }, { projectRoot });
+        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+        return 0;
+      }
+      // Clear the stale story identity before composeRuntimeState runs.
+      // Without this the runtime would re-enter the same story (which is
+      // now done) and verifyStoryDone would loop on "already complete".
+      persisted.current_story = null;
+      persisted.story_file_path = null;
+      persisted.current_epic = null;
+      persisted.current_bmad_step = null;
+      ledger.append(
+        {
+          kind: 'resume',
+          divergence: {
+            kind: 'divergence_accepted',
+            ...accepted,
+            differences: d.differences,
+            last_phase: lastHalt.phase || null,
+          },
+        },
+        { projectRoot },
+      );
     }
   }
 

package/_Sprintpilot/lib/orchestrator/state-store.js

@@ -96,30 +96,101 @@ function readStateFile(fs, filePath) {
 // Narrow YAML parser sufficient for our write shape (the same shape we
 // produce via dumpYaml above). We deliberately avoid js-yaml so we don't
 // pull a runtime dep into the install-time script bundle.
+//
+// Supports:
+//   key: scalar               (inline scalar)
+//   key: [a, b]               (inline JSON array via parseScalar)
+//   key:                      (nested object — children at deeper indent)
+//     subkey: value
+//   key:                      (nested array — `- item` lines at deeper indent)
+//     - item-scalar
+//     - item-key: item-value
+//
+// The block-form array path was added in v2.2.29 — pre-2.2.29 the
+// parser unconditionally `continue`d on any line without `:`, silently
+// dropping every `- item` entry. Hand-edited state files (or any
+// roundtrip through a tool that emits block-form YAML) lost their
+// `story_queue`, leaving the autopilot's queue mysteriously empty.
 function parseYamlNarrow(text) {
   if (!text) return {};
   const lines = text.split(/\r?\n/);
   const root = {};
-  const stack = [{ indent: -1, obj: root }];
+  // Stack frame:
+  //   indent       — indent of the KEY that opened this container (its
+  //                  children live at indent > frame.indent)
+  //   container    — the object or array we're populating
+  //   isArray      — true once we've promoted container from {} to []
+  //   parentObj    — owner of container (used to swap {} → [] when the
+  //                  first child is a `- ` line)
+  //   parentKey    — slot on parentObj that holds container
+  const stack = [{ indent: -1, container: root, isArray: false, parentObj: null, parentKey: null }];
   for (const raw of lines) {
     const hashIdx = raw.indexOf('#');
     const line = hashIdx === -1 ? raw : raw.slice(0, hashIdx);
     if (!line.trim()) continue;
     const indent = line.match(/^( *)/)[1].length;
     const content = line.slice(indent).trimEnd();
+    while (stack.length > 1 && stack[stack.length - 1].indent >= indent) stack.pop();
+    const top = stack[stack.length - 1];
+
+    // List item shape: `- ` or bare `-`.
+    if (content === '-' || content.startsWith('- ')) {
+      // Promote container to array if this is the first list item seen
+      // for the current key. Root-level lists aren't supported (state
+      // files always have an object root) — skip cleanly.
+      if (!top.isArray) {
+        if (!top.parentObj || top.parentKey == null) continue;
+        const arr = [];
+        top.parentObj[top.parentKey] = arr;
+        top.container = arr;
+        top.isArray = true;
+      }
+      const rest = content === '-' ? '' : content.slice(2).trim();
+      if (rest === '') {
+        // Bare `-` with children below — append a fresh object and let
+        // subsequent deeper-indent lines populate it.
+        const child = {};
+        top.container.push(child);
+        stack.push({ indent, container: child, isArray: false, parentObj: null, parentKey: null });
+        continue;
+      }
+      const colon = rest.indexOf(':');
+      if (colon === -1) {
+        // Plain scalar list item.
+        top.container.push(parseScalar(rest));
+        continue;
+      }
+      // `- key: value` or `- key:` (object item).
+      const k = rest.slice(0, colon).trim();
+      const v = rest.slice(colon + 1).trim();
+      if (v === '') {
+        const child = {};
+        const wrapper = { [k]: child };
+        top.container.push(wrapper);
+        stack.push({ indent, container: child, isArray: false, parentObj: wrapper, parentKey: k });
+      } else {
+        top.container.push({ [k]: parseScalar(v) });
+      }
+      continue;
+    }
+
+    // Object key: value
     const colon = content.indexOf(':');
     if (colon === -1) continue;
     const key = content.slice(0, colon).trim();
     const rest = content.slice(colon + 1).trim();
-    while (stack.length > 1 && stack[stack.length - 1].indent >= indent) stack.pop();
-    const parent = stack[stack.length - 1].obj;
+    if (top.isArray) {
+      // Defensive: a stray `key:` inside an array context is malformed.
+      // Skip rather than corrupt the array.
+      continue;
+    }
     if (rest === '') {
       const child = {};
-      parent[key] = child;
-      stack.push({ indent, obj: child });
+      top.container[key] = child;
+      stack.push({ indent, container: child, isArray: false, parentObj: top.container, parentKey: key });
       continue;
     }
-    parent[key] = parseScalar(rest);
+    top.container[key] = parseScalar(rest);
   }
   return root;
 }

package/_Sprintpilot/manifest.yaml

@@ -1,6 +1,6 @@
 addon:
   name: sprintpilot
-  version: 2.2.28
+  version: 2.2.30
   description: Sprintpilot — autopilot and multi-agent addon for BMad Method (git workflow, parallel agents, autonomous story execution)
   bmad_compatibility: ">=6.2.0"
   modules:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ikunin/sprintpilot",
-  "version": "2.2.28",
+  "version": "2.2.30",
   "description": "Sprintpilot — autopilot and multi-agent addon for BMad Method v6: git workflow, parallel agents, autonomous story execution",
   "license": "Apache-2.0",
   "repository": {