@ikunin/sprintpilot 2.0.9 → 2.1.0

package/_Sprintpilot/scripts/log-timing.js

@@ -103,7 +103,10 @@ function validatePhase(s) {
 
 function validateAction(a) {
   if (!VALID_ACTIONS.includes(a)) {
-    return { ok: false, error: `invalid action '${a}': must be one of ${VALID_ACTIONS.join(', ')}` };
+    return {
+      ok: false,
+      error: `invalid action '${a}': must be one of ${VALID_ACTIONS.join(', ')}`,
+    };
   }
   return { ok: true, value: a };
 }
@@ -430,10 +433,16 @@ function main() {
       const r = markPhase(projectRoot, story.value, phase.value, meta.value);
       // Emit a brief JSON line so callers can log the duration if useful.
       // Stdout is intentionally separate from the per-story shard.
-      process.stdout.write(`${JSON.stringify({ marked: phase.value, prev_phase: r.prev_phase, duration_ms: r.duration_ms })}\n`);
+      process.stdout.write(
+        `${JSON.stringify({ marked: phase.value, prev_phase: r.prev_phase, duration_ms: r.duration_ms })}\n`,
+      );
       return;
     }
-    appendLine(projectRoot, story.value, buildEntry(action.value, story.value, phase.value, meta.value));
+    appendLine(
+      projectRoot,
+      story.value,
+      buildEntry(action.value, story.value, phase.value, meta.value),
+    );
   } catch (e) {
     log.error(`timing write failed: ${e.message}`);
     process.exit(1);

package/_Sprintpilot/scripts/merge-shards.js

@@ -115,7 +115,9 @@ function acquireMergeLock(projectRoot) {
         try {
           const st = fs.statSync(file);
           if (Date.now() - st.mtimeMs > STALE_LOCK_AGE_MS) {
-            log.warn(`merge-shards: removing stale lock ${file} (older than ${STALE_LOCK_AGE_MS}ms)`);
+            log.warn(
+              `merge-shards: removing stale lock ${file} (older than ${STALE_LOCK_AGE_MS}ms)`,
+            );
             fs.unlinkSync(file);
             continue;
           }
@@ -201,11 +203,7 @@ function shardUnchanged(file, snapshot) {
   if (!snapshot) return false;
   try {
     const st = fs.statSync(file);
-    return (
-      st.mtimeMs === snapshot.mtime &&
-      st.size === snapshot.size &&
-      st.ino === snapshot.ino
-    );
+    return st.mtimeMs === snapshot.mtime && st.size === snapshot.size && st.ino === snapshot.ino;
   } catch {
     return false;
   }
@@ -421,7 +419,11 @@ function composeStateYaml(stateMerge) {
   if (stateMerge.corrupt.length + stateMerge.invalid.length > 0) {
     doc.shard_problems = [
       ...stateMerge.corrupt.map((c) => ({ story: c.story, kind: 'parse-error', detail: c.error })),
-      ...stateMerge.invalid.map((c) => ({ story: c.story, kind: 'invalid-shape', detail: c.reason })),
+      ...stateMerge.invalid.map((c) => ({
+        story: c.story,
+        kind: 'invalid-shape',
+        detail: c.reason,
+      })),
     ];
   }
   return `${yamlDump(doc)}\n`;
@@ -435,8 +437,16 @@ function composeDecisionYaml(decisionMerge) {
   };
   if (decisionMerge.corrupt.length + decisionMerge.invalid.length > 0) {
     doc.shard_problems = [
-      ...decisionMerge.corrupt.map((c) => ({ story: c.story, kind: 'parse-error', detail: c.error })),
-      ...decisionMerge.invalid.map((c) => ({ story: c.story, kind: 'invalid-shape', detail: c.reason })),
+      ...decisionMerge.corrupt.map((c) => ({
+        story: c.story,
+        kind: 'parse-error',
+        detail: c.error,
+      })),
+      ...decisionMerge.invalid.map((c) => ({
+        story: c.story,
+        kind: 'invalid-shape',
+        detail: c.reason,
+      })),
     ];
   }
   return `${yamlDump(doc)}\n`;
@@ -460,7 +470,13 @@ function merge(projectRoot, { layerId, archive, dryRun } = {}) {
         archivedCorrupt.push({ kind: 'state', story: c.story, ...arch });
       }
       for (const c of decisions.corrupt.concat(decisions.invalid)) {
-        const arch = archiveCorrupt(projectRoot, 'decision-log', c.story, c.file, c.error || c.reason);
+        const arch = archiveCorrupt(
+          projectRoot,
+          'decision-log',
+          c.story,
+          c.file,
+          c.error || c.reason,
+        );
         archivedCorrupt.push({ kind: 'decision-log', story: c.story, ...arch });
       }
     }
@@ -468,8 +484,12 @@ function merge(projectRoot, { layerId, archive, dryRun } = {}) {
     const stateBody = composeStateYaml(state);
     const decisionBody = composeDecisionYaml(decisions);
 
-    const stateWrite = writeAuthoritative(projectRoot, 'autopilot-state.yaml', stateBody, { dryRun });
-    const decisionWrite = writeAuthoritative(projectRoot, 'decision-log.yaml', decisionBody, { dryRun });
+    const stateWrite = writeAuthoritative(projectRoot, 'autopilot-state.yaml', stateBody, {
+      dryRun,
+    });
+    const decisionWrite = writeAuthoritative(projectRoot, 'decision-log.yaml', decisionBody, {
+      dryRun,
+    });
 
     let archiveDir = null;
     let archiveSkipped = [];

package/_Sprintpilot/scripts/post-green-gates.js

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+
+// post-green-gates.js — composed post-GREEN quality pipeline.
+//
+// Called by the orchestrator after a `bmad-dev-story` GREEN phase
+// completes verify. Runs three gates in order; first failing gate causes
+// non-zero exit with a structured JSON report.
+//
+// Gates:
+//   1. lint-changed.js       — biome/eslint on changed files only
+//   2. lint-test-pitfalls.js — LLM-test pitfalls (only on test files)
+//   3. scan.js (ci-parity)   — search for obvious CI-only failure modes
+//                              (envs hard-coded to local-only assumptions)
+//
+// Usage:
+//   post-green-gates.js [--json] [--changed-files <path>] [--project-root <path>]
+//     --changed-files: path to a newline-delimited list of changed files
+//                      (default: derive from `git diff --name-only HEAD`)
+//
+// Each gate runs in a child process via execFileSync. Argv-only — no shell.
+
+const { execFileSync, spawnSync } = require('node:child_process');
+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: post-green-gates.js [--json] [--changed-files <path>] [--project-root <path>]',
+      '',
+      'Runs in order:',
+      '  1. lint-changed.js       — formatter + linter on changed files',
+      '  2. lint-test-pitfalls.js — LLM-test pitfall scan (test files only)',
+      '  3. scan.js (ci-parity)   — CI-only failure mode scan',
+    ].join('\n'),
+  );
+}
+
+function listChangedFiles(projectRoot, override) {
+  if (override) {
+    return fs
+      .readFileSync(override, 'utf8')
+      .split(/\r?\n/)
+      .map((s) => s.trim())
+      .filter((s) => s.length > 0);
+  }
+  try {
+    const out = execFileSync('git', ['diff', '--name-only', 'HEAD'], {
+      cwd: projectRoot,
+      encoding: 'utf8',
+    });
+    return out
+      .split(/\r?\n/)
+      .map((s) => s.trim())
+      .filter(Boolean);
+  } catch (_e) {
+    return [];
+  }
+}
+
+function runGate(name, command, args, projectRoot) {
+  const r = spawnSync(command, args, { cwd: projectRoot, encoding: 'utf8' });
+  return {
+    gate: name,
+    ok: r.status === 0,
+    exit_code: r.status === null ? -1 : r.status,
+    stdout: r.stdout || '',
+    stderr: r.stderr || '',
+  };
+}
+
+function isTestFile(p) {
+  return /\.test\.(ts|tsx|js|jsx|mts)$/.test(p) || /\.spec\.(ts|tsx|js|jsx|mts)$/.test(p);
+}
+
+function isJsTsFile(p) {
+  return /\.(ts|tsx|js|jsx|mts|cjs)$/.test(p);
+}
+
+function main(argv) {
+  const { opts } = parseArgs(argv, { booleanFlags: ['json', 'help'] });
+  if (opts.help) {
+    help();
+    return 0;
+  }
+  const projectRoot = path.resolve(opts['project-root'] || process.cwd());
+  const changed = listChangedFiles(projectRoot, opts['changed-files']);
+  const jsTs = changed.filter(isJsTsFile);
+  const testFiles = changed.filter(isTestFile);
+
+  const gates = [];
+
+  // Gate 1: lint-changed.
+  const lintChangedPath = path.join(projectRoot, '_Sprintpilot', 'scripts', 'lint-changed.js');
+  if (fs.existsSync(lintChangedPath) && jsTs.length > 0) {
+    gates.push(
+      runGate(
+        'lint-changed',
+        'node',
+        [lintChangedPath, '--project-root', projectRoot],
+        projectRoot,
+      ),
+    );
+  } else {
+    gates.push({
+      gate: 'lint-changed',
+      ok: true,
+      exit_code: 0,
+      stdout: 'skipped (no JS/TS changes or script missing)',
+      stderr: '',
+    });
+  }
+
+  // Gate 2: lint-test-pitfalls — only run on test files.
+  const pitfallsPath = path.join(projectRoot, '_Sprintpilot', 'scripts', 'lint-test-pitfalls.js');
+  if (fs.existsSync(pitfallsPath) && testFiles.length > 0) {
+    gates.push(runGate('lint-test-pitfalls', 'node', [pitfallsPath, ...testFiles], projectRoot));
+  } else {
+    gates.push({
+      gate: 'lint-test-pitfalls',
+      ok: true,
+      exit_code: 0,
+      stdout: 'skipped (no test files in change set)',
+      stderr: '',
+    });
+  }
+
+  // Gate 3: ci-parity via scan.js. Pattern set is intentionally conservative
+  // — flag obvious CI-only-fail patterns: `if (!process.env.CI)` skips,
+  // hardcoded localhost ports, `xit`/`xdescribe`. scan.js does the search;
+  // we treat its non-zero exit as a block.
+  const scanPath = path.join(projectRoot, '_Sprintpilot', 'scripts', 'scan.js');
+  if (fs.existsSync(scanPath) && jsTs.length > 0) {
+    gates.push(
+      runGate(
+        'ci-parity',
+        'node',
+        [
+          scanPath,
+          '--pattern',
+          'process.env.CI',
+          '--pattern',
+          '(localhost|127\\.0\\.0\\.1):\\d{4,5}',
+          '--paths',
+          ...jsTs,
+        ],
+        projectRoot,
+      ),
+    );
+  } else {
+    gates.push({
+      gate: 'ci-parity',
+      ok: true,
+      exit_code: 0,
+      stdout: 'skipped (no JS/TS changes or script missing)',
+      stderr: '',
+    });
+  }
+
+  const firstFail = gates.find((g) => !g.ok);
+  const overallOk = !firstFail;
+
+  if (opts.json) {
+    process.stdout.write(
+      `${JSON.stringify({ ok: overallOk, gates, first_fail: firstFail?.gate || null }, null, 2)}\n`,
+    );
+  } else {
+    for (const g of gates) {
+      log.out(`[${g.ok ? '✓' : '✗'}] ${g.gate}: exit=${g.exit_code}`);
+      if (!g.ok) {
+        if (g.stdout) log.out(g.stdout);
+        if (g.stderr) log.err(g.stderr);
+      }
+    }
+    log.out(overallOk ? 'all gates passed' : `failed gate: ${firstFail?.gate}`);
+  }
+  return overallOk ? 0 : 1;
+}
+
+if (require.main === module) {
+  process.exit(main(process.argv.slice(2)));
+}
+
+module.exports = { main, listChangedFiles, runGate, isTestFile, isJsTsFile };

package/_Sprintpilot/scripts/preflight-merge.js

@@ -196,7 +196,8 @@ function main() {
     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 timeout = opts['lock-timeout-sec']
     ? Number.parseInt(String(opts['lock-timeout-sec']), 10)
     : DEFAULT_LOCK_TIMEOUT_SEC;

package/_Sprintpilot/scripts/resolve-dag.js

@@ -568,7 +568,9 @@ function main() {
   }
 
   if (command === 'graph') {
-    process.stdout.write(`${JSON.stringify({ nodes: dag.nodes, edges: dag.edges, epic: dag.epic })}\n`);
+    process.stdout.write(
+      `${JSON.stringify({ nodes: dag.nodes, edges: dag.edges, epic: dag.epic })}\n`,
+    );
     return;
   }
   if (command === 'layers') {

package/_Sprintpilot/scripts/scan.js

@@ -15,6 +15,10 @@
  *               Flags: --include, --exclude, --root
  *   extensions  Extension frequency histogram, descending.
  *               Flags: --exclude, --root, --limit (default 20)
+ *
+ * Ignore files: .gitignore and .aiexclude at the project root are parsed and
+ * applied as additional excludes by default. Pass --no-respect-ignore-files
+ * to disable. Negation patterns (`!pattern`) are logged to stderr and skipped.
  */
 
 const fs = require('fs');
@@ -41,9 +45,74 @@ const DEFAULT_EXCLUDES = [
   '.worktrees',
 ];
 
+const IGNORE_FILES = ['.gitignore', '.aiexclude'];
+
+// Translate one .gitignore / .aiexclude line into zero or more scan.js exclude
+// patterns. Blank lines and `#` comments → []. Negation (`!`) is unsupported
+// and returns []; the caller reports a stderr note. Trailing `/` marks a
+// directory; we expand to both `dir` and `dir/**` so descendant files are also
+// excluded. Leading `/` anchors to the ignore file's directory; we strip it
+// and rely on scan.js's path-anchored exclude semantics for patterns that
+// contain a slash.
+function parseIgnorePattern(line) {
+  let p = line.trim();
+  if (!p || p.startsWith('#')) return { patterns: [], negation: false };
+  if (p.startsWith('!')) return { patterns: [], negation: true };
+  // Unescape leading `\#` and `\!` (gitignore literal escapes).
+  if (p.startsWith('\\#') || p.startsWith('\\!')) p = p.slice(1);
+
+  const isDir = p.endsWith('/');
+  if (isDir) p = p.slice(0, -1);
+
+  const anchored = p.startsWith('/');
+  const body = anchored ? p.slice(1) : p;
+  if (!body) return { patterns: [], negation: false };
+  // compilePatterns handles a leading '/' by anchoring the pattern to the
+  // root, so we keep it intact for anchored patterns.
+  const prefix = anchored ? '/' : '';
+
+  const patterns = [];
+  if (isDir) {
+    patterns.push(`${prefix}${body}`);
+    patterns.push(`${prefix}${body}/**`);
+  } else {
+    patterns.push(`${prefix}${body}`);
+    // A non-anchored pattern that has no slash matches files at any depth as
+    // a basename, which scan.js's matcher already does. If the same name is
+    // also a directory anywhere in the tree, exclude its descendants too.
+    if (!anchored && !body.includes('/')) patterns.push(`**/${body}/**`);
+  }
+  return { patterns, negation: false };
+}
+
+function loadIgnoreFilePatterns(root) {
+  const out = [];
+  let negationCount = 0;
+  for (const name of IGNORE_FILES) {
+    const full = path.join(root, name);
+    let content;
+    try {
+      content = fs.readFileSync(full, 'utf8');
+    } catch {
+      continue;
+    }
+    for (const raw of content.split(/\r?\n/)) {
+      const { patterns, negation } = parseIgnorePattern(raw);
+      if (negation) negationCount++;
+      for (const p of patterns) out.push(p);
+    }
+  }
+  if (negationCount > 0) {
+    log.error(
+      `scan.js: ignored ${negationCount} negation pattern(s) from .gitignore/.aiexclude (not supported)`,
+    );
+  }
+  return out;
+}
+
 function help() {
   log.out(
-    'Usage: scan.js <files|largest|loc|extensions> [--include <globs>] [--exclude <globs>] [--root <path>] [--limit <N>] [--count]',
+    'Usage: scan.js <files|largest|loc|extensions> [--include <globs>] [--exclude <globs>] [--root <path>] [--limit <N>] [--count] [--no-respect-ignore-files]',
   );
 }
 
@@ -183,12 +252,22 @@ function toPosix(p) {
 // pathAnchored = true if the pattern contains a path separator; such patterns
 // only match the full relative path. Basename-only patterns (no '/') match
 // both the full path and the basename, so "*.ts" works at any depth.
+// A leading '/' anchors the pattern to the root (relative paths have no
+// leading slash, so we strip it but keep pathAnchored=true).
 function compilePatterns(patterns) {
-  return patterns.map((p) => ({
-    raw: p,
-    re: globToRegex(p),
-    pathAnchored: p.includes('/'),
-  }));
+  return patterns.map((p) => {
+    let raw = p;
+    let leadingSlash = false;
+    if (raw.startsWith('/')) {
+      raw = raw.slice(1);
+      leadingSlash = true;
+    }
+    return {
+      raw,
+      re: globToRegex(raw),
+      pathAnchored: leadingSlash || raw.includes('/'),
+    };
+  });
 }
 
 function matchesAny(relPath, compiled) {
@@ -335,8 +414,8 @@ function resolveRoot(opts) {
   return root;
 }
 
-function buildExcludes(extra) {
-  const list = [...DEFAULT_EXCLUDES, ...extra];
+function buildExcludes(extra, ignoreFromFiles) {
+  const list = [...DEFAULT_EXCLUDES, ...extra, ...ignoreFromFiles];
   // Patterns: match the basename of a directory OR any path containing it.
   const patterns = [];
   const basenames = new Set();
@@ -352,10 +431,18 @@ function buildExcludes(extra) {
   return { compiled: compilePatterns(patterns), basenames };
 }
 
+function ignoreFilePatternsFor(root, opts) {
+  if (opts['no-respect-ignore-files'] === true) return [];
+  return loadIgnoreFilePatterns(root);
+}
+
 function cmdFiles(opts) {
   const root = resolveRoot(opts);
   const includes = compilePatterns(splitList(opts.include));
-  const { compiled: excludes, basenames } = buildExcludes(splitList(opts.exclude));
+  const { compiled: excludes, basenames } = buildExcludes(
+    splitList(opts.exclude),
+    ignoreFilePatternsFor(root, opts),
+  );
   const limit = opts.limit ? Number(opts.limit) : 0;
   const count = opts.count === true || opts.count === 'true';
 
@@ -378,7 +465,10 @@ function cmdFiles(opts) {
 function cmdLargest(opts) {
   const root = resolveRoot(opts);
   const includes = compilePatterns(splitList(opts.include));
-  const { compiled: excludes, basenames } = buildExcludes(splitList(opts.exclude));
+  const { compiled: excludes, basenames } = buildExcludes(
+    splitList(opts.exclude),
+    ignoreFilePatternsFor(root, opts),
+  );
   const limit = opts.limit ? Number(opts.limit) : 10;
 
   const heap = []; // simple array; N is small so O(files * log N) is fine
@@ -396,7 +486,10 @@ function cmdLargest(opts) {
 function cmdLoc(opts) {
   const root = resolveRoot(opts);
   const includes = compilePatterns(splitList(opts.include));
-  const { compiled: excludes, basenames } = buildExcludes(splitList(opts.exclude));
+  const { compiled: excludes, basenames } = buildExcludes(
+    splitList(opts.exclude),
+    ignoreFilePatternsFor(root, opts),
+  );
 
   let total = 0;
   let fileCount = 0;
@@ -409,7 +502,10 @@ function cmdLoc(opts) {
 
 function cmdExtensions(opts) {
   const root = resolveRoot(opts);
-  const { compiled: excludes, basenames } = buildExcludes(splitList(opts.exclude));
+  const { compiled: excludes, basenames } = buildExcludes(
+    splitList(opts.exclude),
+    ignoreFilePatternsFor(root, opts),
+  );
   const limit = opts.limit ? Number(opts.limit) : 20;
 
   const counts = new Map();
@@ -427,7 +523,7 @@ function cmdExtensions(opts) {
 
 function main() {
   const { opts, positional } = parseArgs(process.argv.slice(2), {
-    booleanFlags: ['count'],
+    booleanFlags: ['count', 'no-respect-ignore-files'],
   });
   if (opts.help || positional.length === 0) {
     help();

package/_Sprintpilot/scripts/stack-snapshot.js

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+
+// stack-snapshot.js — capture a snapshot of the current per-story branch
+// stack so `land-this-pr.js` can land the active PR without losing the
+// rest of the in-flight stack.
+//
+// Output: JSON to stdout (or --output <path>). Shape:
+//   {
+//     base_branch: string,
+//     ts: ISO,
+//     branches: [{ name, head, story_key, status, parent? }],
+//     active_pr: { branch, number?, story_key } | null,
+//   }
+//
+// Argv-only. Uses `git -C <projectRoot>` for every git call.
+
+const { execFileSync } = require('node:child_process');
+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: stack-snapshot.js [--project-root <path>] [--base-branch <name>]',
+      '                         [--output <file>] [--active-branch <name>]',
+      '                         [--story-key <key>] [--pr-number <n>]',
+    ].join('\n'),
+  );
+}
+
+function git(projectRoot, args) {
+  try {
+    return execFileSync('git', ['-C', projectRoot, ...args], { encoding: 'utf8' }).trim();
+  } catch (_e) {
+    return null;
+  }
+}
+
+function listLocalBranches(projectRoot, prefix) {
+  const raw = git(projectRoot, [
+    'for-each-ref',
+    '--format=%(refname:short)\t%(objectname)',
+    `refs/heads/${prefix}`,
+  ]);
+  if (!raw) return [];
+  return raw
+    .split(/\n/)
+    .filter(Boolean)
+    .map((line) => {
+      const [name, head] = line.split('\t');
+      return { name, head };
+    });
+}
+
+function readSprintStatus(projectRoot) {
+  const p = path.join(
+    projectRoot,
+    '_bmad-output',
+    'implementation-artifacts',
+    'sprint-status.yaml',
+  );
+  if (!fs.existsSync(p)) return null;
+  try {
+    return fs.readFileSync(p, 'utf8');
+  } catch (_e) {
+    return null;
+  }
+}
+
+function statusForStory(sprintStatusText, storyKey) {
+  if (!sprintStatusText) return 'unknown';
+  // Narrow regex — accept either "story_key: status" or block form.
+  const re = new RegExp(`^\\s*${storyKey}:\\s*(\\w+)`, 'm');
+  const m = sprintStatusText.match(re);
+  return m ? m[1] : 'unknown';
+}
+
+function snapshot(opts) {
+  const projectRoot = path.resolve(opts['project-root'] || process.cwd());
+  const baseBranch = opts['base-branch'] || 'main';
+  const branches = listLocalBranches(projectRoot, 'story/').map((b) => ({
+    ...b,
+    story_key: b.name.slice('story/'.length),
+  }));
+  const sprintStatus = readSprintStatus(projectRoot);
+  for (const b of branches) {
+    b.status = statusForStory(sprintStatus, b.story_key);
+  }
+  const active =
+    opts['active-branch'] && opts['story-key']
+      ? {
+          branch: opts['active-branch'],
+          story_key: opts['story-key'],
+          number: opts['pr-number'] ? Number(opts['pr-number']) : undefined,
+        }
+      : null;
+  return {
+    base_branch: baseBranch,
+    ts: new Date().toISOString(),
+    branches,
+    active_pr: active,
+  };
+}
+
+function main(argv) {
+  const { opts } = parseArgs(argv, { booleanFlags: ['help'] });
+  if (opts.help) {
+    help();
+    return 0;
+  }
+  const snap = snapshot(opts);
+  const out = `${JSON.stringify(snap, null, 2)}\n`;
+  if (opts.output) {
+    fs.writeFileSync(path.resolve(opts.output), out, 'utf8');
+  } else {
+    process.stdout.write(out);
+  }
+  return 0;
+}
+
+if (require.main === module) {
+  process.exit(main(process.argv.slice(2)));
+}
+
+module.exports = { main, snapshot, statusForStory };

package/_Sprintpilot/scripts/state-shard.js

@@ -575,7 +575,14 @@ function deepAssign(target, source) {
   for (const k of Object.keys(source)) {
     const sv = source[k];
     const tv = out[k];
-    if (sv && typeof sv === 'object' && !Array.isArray(sv) && tv && typeof tv === 'object' && !Array.isArray(tv)) {
+    if (
+      sv &&
+      typeof sv === 'object' &&
+      !Array.isArray(sv) &&
+      tv &&
+      typeof tv === 'object' &&
+      !Array.isArray(tv)
+    ) {
       out[k] = deepAssign(tv, sv);
     } else {
       out[k] = sv;