@ikunin/sprintpilot 2.0.9 → 2.1.0

package/_Sprintpilot/modules/git/config.yaml

@@ -14,6 +14,32 @@ git:
   #           story commit. Set on nano profile by default.
   granularity: story
 
+  # Reuse a user-created branch instead of auto-creating per-story or
+  # per-epic branches. When `true`, autopilot detects the current branch
+  # on boot (must NOT be base_branch) and commits every story directly
+  # onto it. Per-story / per-epic branch creation is suppressed; one PR
+  # is opened at sprint-end. Useful for feature-branch workflows where
+  # the user already has the branch they want to work on.
+  reuse_user_branch: false
+
+  # Merge strategy.
+  #   stacked        — every story branch lives until sprint completes,
+  #                    PRs are stacked (default; existing behavior).
+  #   land_as_you_go — merge each story's PR immediately after STORY_DONE
+  #                    to avoid PR pile-up. `land_when` controls when.
+  merge_strategy: stacked
+
+  # When to merge under merge_strategy: land_as_you_go.
+  #   no_wait        — merge synchronously after STORY_DONE, no CI wait.
+  #   ci_pass        — wait for `gh pr checks` (or platform equivalent)
+  #                    to report all checks green, then merge.
+  #   ci_and_review  — also wait for an `approved` PR review.
+  land_when: ci_pass
+
+  # Max minutes to wait for CI / review under land_as_you_go. After this
+  # the orchestrator halts and prompts the user.
+  land_wait_minutes: 30
+
   # Branch naming
   branch_prefix: "story/" # prefix for story branches (e.g., story/1-2-user-auth)
   max_branch_length: 60 # truncate + 6-char hash if longer

package/_Sprintpilot/scripts/agent-adapter.js

@@ -119,11 +119,10 @@ function parentProcessName() {
   try {
     const pid = process.ppid;
     if (process.platform === 'win32') {
-      const res = spawnSync(
-        'tasklist',
-        ['/FI', `PID eq ${pid}`, '/FO', 'CSV', '/NH'],
-        { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] },
-      );
+      const res = spawnSync('tasklist', ['/FI', `PID eq ${pid}`, '/FO', 'CSV', '/NH'], {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+      });
       if (res.status !== 0) return null;
       return parseTasklistOutput(res.stdout || '');
     }

package/_Sprintpilot/scripts/auto-merge-bmad-docs.js

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+
+// auto-merge-bmad-docs.js — automatically merge BMad documentation
+// updates (decision log, retrospectives, story files) from per-story
+// branches into the base, without running the full per-story PR flow.
+//
+// Use case: after `bmad-create-story` or `bmad-retrospective` produces
+// artifacts that don't affect product code, fast-merge them so the next
+// story can build on the latest sprint state without waiting on review.
+//
+// Scope: only touches files under `_bmad-output/` and recognized
+// SAFE paths. Refuses to merge a branch that has product-code changes.
+
+const { execFileSync } = require('node:child_process');
+const path = require('node:path');
+
+const { parseArgs } = require('../lib/runtime/args');
+const log = require('../lib/runtime/log');
+
+const SAFE_PATHS = ['_bmad-output/', '_bmad/', 'docs/sprint/'];
+
+function help() {
+  log.out(
+    [
+      'Usage: auto-merge-bmad-docs.js --branch <name> [--base <name>]',
+      '                                [--project-root <path>] [--check-only]',
+      '',
+      'Refuses to merge if the branch touches any path outside SAFE_PATHS:',
+      `  ${SAFE_PATHS.join(', ')}`,
+    ].join('\n'),
+  );
+}
+
+function git(projectRoot, args) {
+  return execFileSync('git', ['-C', projectRoot, ...args], { encoding: 'utf8' }).trim();
+}
+
+function changedFiles(projectRoot, branch, base) {
+  return git(projectRoot, ['diff', '--name-only', `${base}...${branch}`])
+    .split(/\n/)
+    .filter(Boolean);
+}
+
+function classifyChanges(files) {
+  const unsafe = files.filter((f) => !SAFE_PATHS.some((prefix) => f.startsWith(prefix)));
+  return { safe: unsafe.length === 0, unsafe };
+}
+
+function main(argv) {
+  const { opts } = parseArgs(argv, { booleanFlags: ['help', 'check-only'] });
+  if (opts.help) {
+    help();
+    return 0;
+  }
+  if (!opts.branch) {
+    log.error('--branch required');
+    return 2;
+  }
+  const projectRoot = path.resolve(opts['project-root'] || process.cwd());
+  const base = opts.base || 'main';
+
+  let files;
+  try {
+    files = changedFiles(projectRoot, opts.branch, base);
+  } catch (e) {
+    log.error(`git diff failed: ${e.message}`);
+    return 1;
+  }
+
+  const classification = classifyChanges(files);
+  const result = {
+    branch: opts.branch,
+    base,
+    files,
+    ...classification,
+  };
+
+  if (opts['check-only']) {
+    process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+    return result.safe ? 0 : 1;
+  }
+
+  if (!result.safe) {
+    log.error(
+      `refusing to auto-merge: branch touches ${result.unsafe.length} non-doc file(s): ${result.unsafe.slice(0, 5).join(', ')}${result.unsafe.length > 5 ? '...' : ''}`,
+    );
+    return 1;
+  }
+
+  // Safe — perform the merge.
+  try {
+    git(projectRoot, ['switch', base]);
+    git(projectRoot, [
+      'merge',
+      '--no-ff',
+      '-m',
+      `Auto-merge BMad docs from ${opts.branch}`,
+      opts.branch,
+    ]);
+  } catch (e) {
+    log.error(`merge failed: ${e.message}`);
+    return 1;
+  }
+  process.stdout.write(`${JSON.stringify({ ...result, merged: true }, null, 2)}\n`);
+  return 0;
+}
+
+if (require.main === module) {
+  process.exit(main(process.argv.slice(2)));
+}
+
+module.exports = { main, classifyChanges, SAFE_PATHS };

package/_Sprintpilot/scripts/dispatch-layer.js

@@ -51,7 +51,10 @@ function help() {
 
 function parseLayer(raw) {
   if (!raw) return { ok: false, error: '--layer is required' };
-  const keys = String(raw).split(',').map((s) => s.trim()).filter(Boolean);
+  const keys = String(raw)
+    .split(',')
+    .map((s) => s.trim())
+    .filter(Boolean);
   for (const k of keys) {
     if (!STORY_RE.test(k)) {
       return { ok: false, error: `invalid story key '${k}': must match ${STORY_RE}` };
@@ -133,11 +136,10 @@ function createWorktree({ projectRoot, worktree, branch, baseBranch }) {
       stderr: first.stderr || '',
     };
   }
-  const second = spawnSync(
-    'git',
-    ['-C', projectRoot, 'worktree', 'add', worktree, branch],
-    { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] },
-  );
+  const second = spawnSync('git', ['-C', projectRoot, 'worktree', 'add', worktree, branch], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
   return {
     created: second.status === 0,
     retried: true,
@@ -260,13 +262,15 @@ function main() {
     log.error(layer.error);
     process.exit(1);
   }
-  const maxParallel = opts['max-parallel'] !== undefined ? Number.parseInt(String(opts['max-parallel']), 10) : 2;
+  const maxParallel =
+    opts['max-parallel'] !== undefined ? Number.parseInt(String(opts['max-parallel']), 10) : 2;
   if (Number.isNaN(maxParallel) || maxParallel < 1) {
     log.error(`invalid --max-parallel '${opts['max-parallel']}': must be a positive integer`);
     process.exit(1);
   }
   const projectRoot = opts['project-root'] || process.cwd();
-  const branchPrefix = opts['branch-prefix'] !== undefined ? String(opts['branch-prefix']) : 'story/';
+  const branchPrefix =
+    opts['branch-prefix'] !== undefined ? String(opts['branch-prefix']) : 'story/';
   const baseBranch = opts['base-branch'] !== undefined ? String(opts['base-branch']) : 'main';
   const dryRun = opts['dry-run'] === true;
 

package/_Sprintpilot/scripts/infer-dependencies.js

@@ -137,7 +137,11 @@ function validateEnvelope(envelope, { projectRoot, epic }) {
     return { valid: false, errors };
   }
   if (envelope.version !== 1) {
-    push({ code: 'schema', field: 'version', message: `expected version === 1, got ${JSON.stringify(envelope.version)}` });
+    push({
+      code: 'schema',
+      field: 'version',
+      message: `expected version === 1, got ${JSON.stringify(envelope.version)}`,
+    });
   }
   if (typeof envelope.epic !== 'string' || envelope.epic !== String(epic)) {
     push({
@@ -149,10 +153,23 @@ function validateEnvelope(envelope, { projectRoot, epic }) {
   const deps = envelope.dependencies;
   const rationale = envelope.rationale;
   if (deps === undefined || deps === null || typeof deps !== 'object' || Array.isArray(deps)) {
-    push({ code: 'schema', field: 'dependencies', message: 'must be an object of { storyKey: [depKey, ...] }' });
+    push({
+      code: 'schema',
+      field: 'dependencies',
+      message: 'must be an object of { storyKey: [depKey, ...] }',
+    });
   }
-  if (rationale === undefined || rationale === null || typeof rationale !== 'object' || Array.isArray(rationale)) {
-    push({ code: 'schema', field: 'rationale', message: 'must be an object of { storyKey: "string" }' });
+  if (
+    rationale === undefined ||
+    rationale === null ||
+    typeof rationale !== 'object' ||
+    Array.isArray(rationale)
+  ) {
+    push({
+      code: 'schema',
+      field: 'rationale',
+      message: 'must be an object of { storyKey: "string" }',
+    });
   }
   // Stop here on root-level shape failures — the per-key checks below assume valid containers.
   if (errors.length > 0) return { valid: false, errors };
@@ -163,15 +180,27 @@ function validateEnvelope(envelope, { projectRoot, epic }) {
   for (const key of Object.keys(deps)) {
     const arr = deps[key];
     if (!Array.isArray(arr)) {
-      push({ code: 'schema', field: `dependencies.${key}`, message: 'must be an array of story keys' });
+      push({
+        code: 'schema',
+        field: `dependencies.${key}`,
+        message: 'must be an array of story keys',
+      });
       continue;
     }
     if (!validKeys.has(key)) {
-      push({ code: 'unknown-key', key, message: `story "${key}" not present in sprint-status.yaml for epic ${epic}` });
+      push({
+        code: 'unknown-key',
+        key,
+        message: `story "${key}" not present in sprint-status.yaml for epic ${epic}`,
+      });
     }
     for (const dep of arr) {
       if (typeof dep !== 'string') {
-        push({ code: 'schema', field: `dependencies.${key}[]`, message: `dep entries must be strings, got ${JSON.stringify(dep)}` });
+        push({
+          code: 'schema',
+          field: `dependencies.${key}[]`,
+          message: `dep entries must be strings, got ${JSON.stringify(dep)}`,
+        });
         continue;
       }
       if (dep === key) {
@@ -189,13 +218,21 @@ function validateEnvelope(envelope, { projectRoot, epic }) {
         continue;
       }
       if (!validKeys.has(dep)) {
-        push({ code: 'unknown-key', key: dep, message: `dependency "${dep}" of "${key}" not in sprint-status.yaml` });
+        push({
+          code: 'unknown-key',
+          key: dep,
+          message: `dependency "${dep}" of "${key}" not in sprint-status.yaml`,
+        });
       }
     }
     // Rationale required for every declared key.
     const r = rationale[key];
     if (typeof r !== 'string' || r.trim() === '') {
-      push({ code: 'schema', field: `rationale.${key}`, message: 'rationale required for every key in dependencies (non-empty string)' });
+      push({
+        code: 'schema',
+        field: `rationale.${key}`,
+        message: 'rationale required for every key in dependencies (non-empty string)',
+      });
     }
   }
 
@@ -218,7 +255,11 @@ function validateEnvelope(envelope, { projectRoot, epic }) {
     }
     const { cycle } = topoLayers(allKeys, edges);
     if (cycle.length > 0) {
-      push({ code: 'cycle', nodes: cycle.slice().sort(), message: `cyclic dependency among: ${cycle.slice().sort().join(', ')}` });
+      push({
+        code: 'cycle',
+        nodes: cycle.slice().sort(),
+        message: `cyclic dependency among: ${cycle.slice().sort().join(', ')}`,
+      });
     }
   }
 
@@ -255,10 +296,16 @@ function mergeDoc(envelope, existing) {
     };
   }
   // overrides + epics: preserved from existing if present, else empty defaults.
-  const overrides = existing && existing.doc && Array.isArray(existing.doc.overrides) ? existing.doc.overrides : [];
-  const epics = existing && existing.doc && existing.doc.epics && typeof existing.doc.epics === 'object' && !Array.isArray(existing.doc.epics)
-    ? existing.doc.epics
-    : {};
+  const overrides =
+    existing && existing.doc && Array.isArray(existing.doc.overrides) ? existing.doc.overrides : [];
+  const epics =
+    existing &&
+    existing.doc &&
+    existing.doc.epics &&
+    typeof existing.doc.epics === 'object' &&
+    !Array.isArray(existing.doc.epics)
+      ? existing.doc.epics
+      : {};
   return { version: 1, stories, overrides, epics };
 }
 
@@ -342,16 +389,17 @@ function renderYaml(doc, hash) {
       }
       const first = ovKeys[0];
       const firstVal = ov[first];
-      if (Array.isArray(firstVal) || (typeof firstVal !== 'object' || firstVal === null)) {
+      if (Array.isArray(firstVal) || typeof firstVal !== 'object' || firstVal === null) {
         lines.push(`  - ${first}: ${inlineScalar(firstVal)}`);
       } else {
         lines.push(`  - ${first}:`);
-        for (const sk of Object.keys(firstVal)) lines.push(`      ${sk}: ${inlineScalar(firstVal[sk])}`);
+        for (const sk of Object.keys(firstVal))
+          lines.push(`      ${sk}: ${inlineScalar(firstVal[sk])}`);
       }
       for (let i = 1; i < ovKeys.length; i++) {
         const k = ovKeys[i];
         const v = ov[k];
-        if (Array.isArray(v) || (typeof v !== 'object' || v === null)) {
+        if (Array.isArray(v) || typeof v !== 'object' || v === null) {
           lines.push(`    ${k}: ${inlineScalar(v)}`);
         } else {
           lines.push(`    ${k}:`);
@@ -465,7 +513,10 @@ async function runDryRun(projectRoot, epic) {
     envelope = JSON.parse(stdin);
   } catch (e) {
     process.stdout.write(
-      JSON.stringify({ valid: false, errors: [{ code: 'schema', field: 'root', message: `invalid JSON: ${e.message}` }] }) + '\n',
+      JSON.stringify({
+        valid: false,
+        errors: [{ code: 'schema', field: 'root', message: `invalid JSON: ${e.message}` }],
+      }) + '\n',
     );
     return 1;
   }
@@ -477,7 +528,9 @@ async function runDryRun(projectRoot, epic) {
   const existing = readExisting(projectRoot);
   const merged = mergeDoc(envelope, existing);
   const diff = diffCounts(existing.doc, merged);
-  process.stdout.write(JSON.stringify({ valid: true, errors: [], merged_doc: merged, diff }) + '\n');
+  process.stdout.write(
+    JSON.stringify({ valid: true, errors: [], merged_doc: merged, diff }) + '\n',
+  );
   return 0;
 }
 
@@ -502,7 +555,10 @@ async function runWrite(projectRoot, epic, { force }) {
     envelope = JSON.parse(stdin);
   } catch (e) {
     process.stdout.write(
-      JSON.stringify({ valid: false, errors: [{ code: 'schema', field: 'root', message: `invalid JSON: ${e.message}` }] }) + '\n',
+      JSON.stringify({
+        valid: false,
+        errors: [{ code: 'schema', field: 'root', message: `invalid JSON: ${e.message}` }],
+      }) + '\n',
     );
     return 1;
   }
@@ -569,7 +625,8 @@ async function main() {
   try {
     if (command === 'scaffold-prompt') process.exit(await runScaffoldPrompt(projectRoot, epic));
     if (command === 'dry-run') process.exit(await runDryRun(projectRoot, epic));
-    if (command === 'write') process.exit(await runWrite(projectRoot, epic, { force: opts.force === true }));
+    if (command === 'write')
+      process.exit(await runWrite(projectRoot, epic, { force: opts.force === true }));
   } catch (e) {
     log.error(`unexpected error: ${e.stack || e.message}`);
     process.exit(1);

package/_Sprintpilot/scripts/inject-tasks-section.js

@@ -249,9 +249,10 @@ function main() {
     const headerRe = /^(#{2,})\s+(tasks|subtasks)(\s*\/\s*(tasks|subtasks))?\s*$/i;
     for (let i = 0; i < lines.length; i++) {
       if (headerRe.test(lines[i])) {
-        const injection = entries.length === 0
-          ? ['', '- [ ] Implement story per Acceptance Criteria', '']
-          : ['', ...entries.map((e) => `- [ ] ${e}`), ''];
+        const injection =
+          entries.length === 0
+            ? ['', '- [ ] Implement story per Acceptance Criteria', '']
+            : ['', ...entries.map((e) => `- [ ] ${e}`), ''];
         lines.splice(i + 1, 0, ...injection);
         break;
       }

package/_Sprintpilot/scripts/land-this-pr.js

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+
+// land-this-pr.js — produce the argv sequence that lands the active PR
+// from a stack snapshot. Land = merge into base + delete the local
+// branch + rebase the rest of the stack.
+//
+// Reads a stack snapshot produced by stack-snapshot.js (--snapshot <path>),
+// outputs an ordered list of git commands. Does NOT execute them — the
+// orchestrator CLI runs each step through its retry/error pipeline.
+//
+// merge_strategy honors the active profile's squash_on_merge.
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { parseArgs } = require('../lib/runtime/args');
+const log = require('../lib/runtime/log');
+
+function help() {
+  log.out(
+    [
+      'Usage: land-this-pr.js --snapshot <path> [--squash] [--base <name>]',
+      '                       [--output <path>]',
+      '',
+      'Reads a stack snapshot, outputs an argv-step plan to land the active PR.',
+    ].join('\n'),
+  );
+}
+
+function buildPlan(snapshot, opts) {
+  if (!snapshot || !snapshot.active_pr) {
+    return { steps: [], skipped: true, reason: 'no active_pr in snapshot' };
+  }
+  const base = opts.base || snapshot.base_branch || 'main';
+  const branch = snapshot.active_pr.branch;
+  const squash = !!opts.squash;
+
+  const steps = [];
+  steps.push({ args: ['git', 'fetch', 'origin'], description: 'sync remote' });
+  steps.push({ args: ['git', 'switch', base], description: `switch to ${base}` });
+  steps.push({
+    args: ['git', 'merge', '--ff-only', `origin/${base}`],
+    description: 'ff base to remote',
+  });
+  if (squash) {
+    steps.push({ args: ['git', 'merge', '--squash', branch], description: 'squash-merge' });
+    steps.push({
+      args: ['git', 'commit', '-m', `feat(${snapshot.active_pr.story_key}): land`],
+      description: 'squash commit',
+    });
+  } else {
+    steps.push({
+      args: ['git', 'merge', '--no-ff', '-m', `Merge ${branch}`, branch],
+      description: 'non-ff merge',
+    });
+  }
+  steps.push({
+    args: ['git', 'push', 'origin', base],
+    description: `push ${base}`,
+    retry: { attempts: 4, backoff_ms: [2000, 4000, 8000, 16000], on: 'network' },
+  });
+  steps.push({
+    args: ['git', 'branch', '-d', branch],
+    description: `delete local ${branch}`,
+  });
+
+  // Rebase the rest of the stack onto the new base.
+  const rest = (snapshot.branches || []).filter((b) => b.name !== branch && b.status !== 'done');
+  for (const b of rest) {
+    steps.push({
+      args: ['git', 'rebase', base, b.name],
+      description: `rebase ${b.name} onto ${base}`,
+    });
+  }
+
+  return { steps, skipped: false, branch, base, rebased: rest.map((b) => b.name) };
+}
+
+function main(argv) {
+  const { opts } = parseArgs(argv, { booleanFlags: ['help', 'squash'] });
+  if (opts.help) {
+    help();
+    return 0;
+  }
+  if (!opts.snapshot) {
+    log.error('--snapshot <path> required');
+    return 2;
+  }
+  let snap;
+  try {
+    snap = JSON.parse(fs.readFileSync(path.resolve(opts.snapshot), 'utf8'));
+  } catch (e) {
+    log.error(`snapshot read failed: ${e.message}`);
+    return 1;
+  }
+  const plan = buildPlan(snap, opts);
+  const text = `${JSON.stringify(plan, null, 2)}\n`;
+  if (opts.output) {
+    fs.writeFileSync(path.resolve(opts.output), text, 'utf8');
+  } else {
+    process.stdout.write(text);
+  }
+  return 0;
+}
+
+if (require.main === module) {
+  process.exit(main(process.argv.slice(2)));
+}
+
+module.exports = { main, buildPlan };

package/_Sprintpilot/scripts/lint-test-pitfalls.js

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+
+// lint-test-pitfalls.js — scan test files for common LLM-authored mistakes
+// that make tests pass locally but fail under different conditions or hide
+// real bugs.
+//
+// Run as part of post-green-gates.js after the GREEN phase. Reports issues
+// per file; exits 0 if no issues, 1 if any "block" issue found.
+//
+// Detected pitfalls:
+//   - it.only / describe.only / xit / xdescribe — focused/disabled tests
+//   - expect(true).toBe(true) and equivalent tautologies
+//   - Promise without await (potential unhandled rejection in test)
+//   - process.exit() inside a test (kills the runner)
+//   - Hard-coded paths to /tmp / C:\ — not portable
+//
+// Pure-ish: takes a list of files via argv, reads via fs, prints JSON.
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { parseArgs } = require('../lib/runtime/args');
+const log = require('../lib/runtime/log');
+
+const PITFALLS = [
+  {
+    id: 'focused_or_skipped',
+    severity: 'block',
+    re: /\b(?:it|describe)\.only\b|\bxit\b|\bxdescribe\b/g,
+    message: 'focused (.only) or skipped (xit/xdescribe) tests',
+  },
+  {
+    id: 'tautological_expect',
+    severity: 'block',
+    re: /expect\(\s*(true|false|1|0|"")\s*\)\.toBe\(\s*\1\s*\)/g,
+    message: 'tautological expect (e.g. expect(true).toBe(true))',
+  },
+  {
+    id: 'process_exit_in_test',
+    severity: 'block',
+    re: /\bprocess\.exit\(/g,
+    message: 'process.exit() inside test source — kills the runner',
+  },
+  {
+    id: 'hardcoded_absolute_path',
+    severity: 'warn',
+    // Match /tmp/... or C:\... at start of a string literal
+    re: /["'](\/tmp\/|[A-Za-z]:\\)/g,
+    message: 'hard-coded absolute path — use os.tmpdir() / path.join()',
+  },
+  {
+    id: 'missing_await_on_promise',
+    severity: 'warn',
+    re: /^\s*(?:fetch|axios|page|request)\s*\(/gm,
+    message: 'looks like a promise call without await — verify intent',
+  },
+];
+
+function help() {
+  log.out(
+    [
+      'Usage: lint-test-pitfalls.js [--json] <files...>',
+      '  --json    Emit structured JSON (default: human-readable)',
+    ].join('\n'),
+  );
+}
+
+function scanFile(filePath) {
+  let text;
+  try {
+    text = fs.readFileSync(filePath, 'utf8');
+  } catch (e) {
+    return { file: filePath, error: e.message, issues: [] };
+  }
+  const issues = [];
+  for (const p of PITFALLS) {
+    p.re.lastIndex = 0;
+    let m;
+    while ((m = p.re.exec(text))) {
+      const line = text.slice(0, m.index).split('\n').length;
+      issues.push({
+        id: p.id,
+        severity: p.severity,
+        line,
+        message: p.message,
+        match: m[0],
+      });
+    }
+  }
+  return { file: filePath, issues };
+}
+
+function main(argv) {
+  const { opts, positional } = parseArgs(argv, { booleanFlags: ['json', 'help'] });
+  if (opts.help) {
+    help();
+    return 0;
+  }
+  if (positional.length === 0) {
+    help();
+    return 2;
+  }
+
+  const reports = positional.map((f) => scanFile(path.resolve(f)));
+  let blockCount = 0;
+  let warnCount = 0;
+  for (const r of reports) {
+    for (const i of r.issues) {
+      if (i.severity === 'block') blockCount += 1;
+      else if (i.severity === 'warn') warnCount += 1;
+    }
+  }
+
+  if (opts.json) {
+    process.stdout.write(`${JSON.stringify({ reports, blockCount, warnCount }, null, 2)}\n`);
+  } else {
+    for (const r of reports) {
+      if (r.issues.length === 0) continue;
+      log.out(`${r.file}:`);
+      for (const i of r.issues) {
+        log.out(`  L${i.line} [${i.severity}] ${i.message}: ${i.match}`);
+      }
+    }
+    log.out(`\n${blockCount} blocking, ${warnCount} warning`);
+  }
+  return blockCount > 0 ? 1 : 0;
+}
+
+if (require.main === module) {
+  process.exit(main(process.argv.slice(2)));
+}
+
+module.exports = { main, scanFile, PITFALLS };

package/_Sprintpilot/scripts/list-remaining-stories.js

@@ -83,7 +83,7 @@ function leadingIndent(line) {
 // {key, value} or null. Handles trailing `# comment`.
 function parseKV(content) {
   const m = content.match(
-    /^["']?([A-Za-z0-9][A-Za-z0-9_.\-]*)["']?\s*:\s*(\S[^#]*?)?(?:\s*#.*)?\s*$/,
+    /^["']?([A-Za-z0-9][A-Za-z0-9_.-]*)["']?\s*:\s*(\S[^#]*?)?(?:\s*#.*)?\s*$/,
   );
   if (!m) return null;
   return { key: m[1], value: m[2] ? stripQuotes(m[2].trim()) : '' };