trackfw 7.0.0 → 7.1.0

package/src/integrations/manager.js

@@ -30,6 +30,14 @@ class IntegrationManager {
   constructor({ projectRoot = process.cwd(), homeRoot = os.homedir() } = {}, { onSkip } = {}) {
     this.roots = { project: path.resolve(projectRoot), global: path.resolve(homeRoot) }
     this.onSkip = onSkip
+    // _afterManifestPersist, when set, runs immediately after manifests are
+    // persisted and before artifact bytes are written during install/update
+    // (never during uninstall, which is intentionally not inverted — see the
+    // comment in mutate()). It exists only so tests can simulate an
+    // interruption exactly at the ADR-2026-08-18 ordering seam. Production
+    // code never assigns it. Mirrors internal/integrations/manager.go's
+    // afterManifestPersist package var.
+    this._afterManifestPersist = undefined
   }
 
   manifestPath(scope) { return path.join(this.roots[scope], '.trackfw', 'integrations-manifest.json') }
@@ -118,7 +126,16 @@ class IntegrationManager {
       const file = this.resolve(scope, plan.destination)
       const record = manifests.get(scope).artifacts[file]
       const managed = Boolean(record && record.claims.some(claim => claimKey(claim) === claimKey(plan.claim)))
-      if (!fs.existsSync(file)) return { ...plan, destination: file, state: 'not-installed', managed }
+      // registered reports whether the manifest has ANY entry for this
+      // destination, regardless of claim ownership — unlike managed, which
+      // additionally requires this exact claim to own that entry. doctor
+      // (ML-2A) needs this distinction: a destination registered under a
+      // *different* claim must never be reported as an "unregistered
+      // write" — that would be the dominant false-positive doctor exists to
+      // avoid. Additive field; mirrors Inspection.Registered
+      // (internal/integrations/manager.go).
+      const registered = Boolean(record)
+      if (!fs.existsSync(file)) return { ...plan, destination: file, state: 'not-installed', managed, registered }
       const actual = sha256(fs.readFileSync(file))
       const desired = sha256(plan.content)
       let state
@@ -129,7 +146,7 @@ class IntegrationManager {
       } else if (actual === desired) state = 'current'
       else if ((plan.legacyHashes || []).includes(actual)) state = 'outdated'
       else state = 'modified'
-      return { ...plan, destination: file, state, managed }
+      return { ...plan, destination: file, state, managed, registered }
     })
   }
 
@@ -167,9 +184,44 @@ class IntegrationManager {
     const snapshots = new Map()
     for (const item of active) this.snapshot(snapshots, item.file)
     for (const scope of manifests.keys()) this.snapshot(snapshots, this.manifestPath(scope))
-    try {
-      for (const item of active) this.apply(operation, item, manifests.get(item.plan.claim.scope), force)
+    const saveManifests = () => {
       for (const [scope, manifest] of [...manifests].sort(([a], [b]) => a.localeCompare(b))) this.saveManifest(scope, manifest)
+    }
+    try {
+      // ADR-2026-08-18: install/update persist the manifest before writing
+      // artifact bytes (self-healing direction on interruption); uninstall
+      // keeps the original artifacts-before-manifest order. The two are
+      // deliberately NOT symmetric.
+      if (operation === 'uninstall') {
+        // Uninstall is not inverted. Removing bytes first and persisting the
+        // manifest last means an interruption leaves the manifest still
+        // declaring an artifact whose file is now absent — inspectResolved
+        // resolves that as 'not-installed', the same self-healing direction
+        // install/update get from the inversion below. Inverting uninstall
+        // the same way (drop the manifest entry, then remove bytes) would
+        // instead leave, on interruption, a file on disk whose content still
+        // matches the catalog template but with no manifest entry at all —
+        // reported as an orphaned state='current'/managed=false artifact
+        // that looks legitimate and that nothing detects or repairs
+        // automatically. That is exactly the "disk ahead of manifest" bad
+        // direction the ADR exists to eliminate, so uninstall must not be
+        // simetrized with install/update here. Mirrors the comment in
+        // internal/integrations/manager.go:mutate.
+        for (const item of active) this.applyUninstall(item, manifests.get(item.plan.claim.scope))
+        saveManifests()
+      } else {
+        // Install/Update: compute the manifest update for every active item
+        // in memory (no bytes touched yet), persist all manifests, and only
+        // then write the artifact bytes.
+        const pendingWrites = []
+        for (const item of active) {
+          const write = this.planArtifactWrite(operation, item, manifests.get(item.plan.claim.scope), force)
+          if (write) pendingWrites.push(write)
+        }
+        saveManifests()
+        if (typeof this._afterManifestPersist === 'function') this._afterManifestPersist()
+        for (const write of pendingWrites) this.atomicWrite(write.file, write.content, write.mode)
+      }
     } catch (error) {
       this.rollback(snapshots)
       throw error
@@ -186,7 +238,7 @@ class IntegrationManager {
       if (status.state === 'modified' && !force) throw new Error(`Artifact is modified; use --force: ${file}`)
       if (status.state === 'outdated' && owned && !force) return true // skip: bytes preserved, batch continues
     } else if (operation === 'update') {
-      if (!owned && status.state === 'modified') throw new Error(`Unmanaged artifact does not match a trackfw template: ${file}`)
+      if (!owned && status.state === 'modified') throw new Error(this.unmanagedArtifactError(file, plan.claim))
       if (status.state === 'modified' && !force) throw new Error(`Artifact is modified; use --force: ${file}`)
     } else if (operation === 'uninstall' && owned && status.state === 'modified' && !force) {
       throw new Error(`Artifact is modified; use --force: ${file}`)
@@ -256,19 +308,42 @@ class IntegrationManager {
     return { state: 'modified', managed: false }
   }
 
-  apply(operation, { plan, file }, manifest, force) {
+  // applyUninstall removes ownership of one artifact from the manifest, and —
+  // once no claim remains — the artifact's bytes and any empty ancestor
+  // directories it managed. It mutates disk directly (not deferred), because
+  // uninstall deliberately keeps the pre-ADR-2026-08-18 ordering: see the
+  // comment in mutate() for why this is not simetrized with
+  // planArtifactWrite. Mirrors internal/integrations/manager.go:applyUninstall.
+  applyUninstall({ plan, file }, manifest) {
+    const record = manifest.artifacts[file]
+    const key = claimKey(plan.claim)
+    const owned = Boolean(record && record.claims.some(claim => claimKey(claim) === key))
+    if (!owned) return
+    record.claims = record.claims.filter(claim => claimKey(claim) !== key)
+    if (record.claims.length) return
+    if (fs.existsSync(file)) fs.unlinkSync(file)
+    delete manifest.artifacts[file]
+    this.cleanEmpty(path.dirname(file), this.roots[plan.claim.scope])
+  }
+
+  // planArtifactWrite computes the manifest update for one install/update
+  // item entirely in memory — it never touches the artifact's bytes on disk.
+  // The caller (mutate) persists every manifest in the batch first, and only
+  // then applies the returned pending write (ADR-2026-08-18). Returns null
+  // when no byte write is needed.
+  //
+  // The manifest values it stores are deliberately *optimistic* when a write
+  // is pending: sha256/catalog_version describe the content this call is
+  // about to write, not what is currently on disk. If interrupted before the
+  // pending write lands, the manifest already declares the target state and
+  // inspectResolved resolves the (absent or stale) file to
+  // 'not-installed'/'modified', both self-repairable by a later
+  // install/update, never modified+unowned ("unmanaged"). Mirrors
+  // internal/integrations/manager.go:planArtifactWrite.
+  planArtifactWrite(operation, { plan, file }, manifest, force) {
     let record = manifest.artifacts[file]
     const key = claimKey(plan.claim)
     const owned = Boolean(record && record.claims.some(claim => claimKey(claim) === key))
-    if (operation === 'uninstall') {
-      if (!owned) return
-      record.claims = record.claims.filter(claim => claimKey(claim) !== key)
-      if (record.claims.length) return
-      if (fs.existsSync(file)) fs.unlinkSync(file)
-      delete manifest.artifacts[file]
-      this.cleanEmpty(path.dirname(file), this.roots[plan.claim.scope])
-      return
-    }
 
     const exists = fs.existsSync(file)
     let actual = exists ? sha256(fs.readFileSync(file)) : ''
@@ -278,16 +353,29 @@ class IntegrationManager {
     if (exists && !owned) writeDesired = (operation === 'update' && actual !== desired) || (force && actual !== desired)
     else if (exists && owned) writeDesired = actual !== desired
     if (!record) record = { destination: file, sha256: '', catalog_version: '', claims: [] }
+    let pending = null
     if (writeDesired) {
-      this.atomicWrite(file, plan.content, 0o644)
+      // Optimistic: bytes have not moved yet, but the manifest must already
+      // describe the content we are about to write (see doc comment above).
       actual = desired
+      pending = { file, content: plan.content, mode: 0o644 }
     } else if (exists && !owned && actual !== desired && !knownLegacy && !force) {
-      throw new Error(`Unmanaged artifact does not match a trackfw template: ${file}`)
+      // Defense-in-depth: preflight already rejects this exact case for
+      // 'update' (unconditionally) and for 'install' without --force (any
+      // state === 'modified' is blocked before an active item ever reaches
+      // planArtifactWrite()). This branch is therefore not reachable via
+      // install/update today, but stays as a second line of defense in case
+      // preflight's guard is ever loosened — hence the identical remediation
+      // text, so a user who somehow hits it still gets the same actionable
+      // message. No manifest mutation happens on this path. Mirrors
+      // internal/integrations/manager.go:planArtifactWrite.
+      throw new Error(this.unmanagedArtifactError(file, plan.claim))
     }
     if (!record.claims.some(claim => claimKey(claim) === key)) record.claims.push(cleanClaim(plan.claim))
     record.sha256 = actual
     record.catalog_version = actual === desired ? plan.catalogVersion : 'legacy'
     manifest.artifacts[file] = record
+    return pending
   }
 
   snapshot(snapshots, file) {
@@ -305,6 +393,19 @@ class IntegrationManager {
     }
   }
 
+  // unmanagedArtifactError — mensagem de erro para update/uninstall (ou,
+  // defensivamente, install) recusando bytes que o trackfw não escreveu.
+  // Nomeia o remédio — trackfw did not write these bytes, então a única forma
+  // segura de trazer o artefato sob gestão é `<kind> install --force`, que
+  // explicitamente autoriza adotar/substituir conteúdo unmanaged — com as
+  // flags exatas para reproduzir o claim deste plano (item, target, scope),
+  // prontas para copiar e colar. Espelha
+  // internal/integrations/manager.go:unmanagedArtifactError — fonte canônica
+  // do texto, byte a byte idêntica nos 3 CLIs.
+  unmanagedArtifactError(file, claim) {
+    return `unmanaged artifact "${file}" does not match a trackfw template — trackfw did not write these bytes.\nAdopt it with: trackfw ${claim.kind} install --force --items ${claim.item} --targets ${claim.target} --scope ${claim.scope}`
+  }
+
   // tildeAbbrev — retorna o caminho de exibição abreviado para uso em mensagens
   // de aviso de skip. Espelha internal/integrations/manager.go:tildeAbbrev.
   // - scope global: substitui homeRoot por '~' (via tildeify, com salvaguarda

package/src/lib/fatal-error.js

@@ -0,0 +1,64 @@
+'use strict'
+
+const fs = require('node:fs')
+
+// fatal-error.js — global backstop for errors that escape every commander
+// action (sync or async, since npm/bin/trackfw drives the program via
+// parseAsync()). Installed ONCE at the entrypoint, never per-command:
+// the real leak pattern (REQ-2026-08-16-erro-nao-tratado-no-cli-node-vaza-
+// stack-trace-caminhos-absolutos-e-versao-do-runtime) was per-command —
+// commands that catch internally (e.g. `roadmap move`) already print a
+// clean message via console.error + process.exitCode, but any command that
+// doesn't catch let Node's own uncaught-exception/unhandled-rejection
+// printer dump the full stack, absolute install path and runtime version.
+// A single handler at the entrypoint closes every one of those gaps at
+// once instead of relying on every future command remembering a try/catch.
+//
+// TRACKFW_DEBUG=1 restores the full stack — this must never blind someone
+// who genuinely needs to debug a crash.
+//
+// Writes with fs.writeSync(2, ...) — NOT process.stderr.write() — on
+// purpose: installGlobalHandlers() below calls process.exit() right after
+// this returns, and when stderr is a pipe (exactly what every spawnSync-
+// based test in this repo uses, and what a piped CI log is) Node's stream
+// writes are asynchronous; process.exit() can drop a still-pending write
+// before the OS ever sees it, silently eating the message (failure mode
+// #2 in the REQ: "engolir a mensagem" — worse than the leak this handler
+// exists to fix). fs.writeSync is a raw, synchronous syscall — it cannot
+// race process.exit().
+function reportFatalError(err) {
+  // TRACKFW_DEBUG=1: print the full stack (its first line already is
+  // "Error: <message>", so this is the debug-only superset of the clean
+  // path below, not a duplicate of it).
+  if (process.env.TRACKFW_DEBUG === '1' && err && err.stack) {
+    fs.writeSync(2, `${err.stack}\n`)
+    return
+  }
+  const message = err && err.message !== undefined ? err.message : String(err)
+  fs.writeSync(2, `Error: ${message}\n`)
+}
+
+// installGlobalHandlers — defense in depth beyond the parseAsync().catch()
+// in bin/trackfw. Covers errors that reach the process outside that single
+// promise chain (e.g. a rejection from a detached/floating promise started
+// by a command, or a genuine uncaughtException). Per Node's own contract,
+// once a listener is attached Node no longer prints its default trace and
+// no longer auto-exits — the listener owns both the message and the exit.
+// Both listeners call process.exit() immediately after reportFatalError()
+// returns — safe here specifically because reportFatalError writes
+// synchronously (see comment above); process.exitCode (which waits for the
+// event loop to drain) would be wrong here regardless, since long-running
+// commands (e.g. `serve`) hold the loop open and the process would hang
+// instead of exiting on a genuinely fatal error.
+function installGlobalHandlers() {
+  process.on('unhandledRejection', (err) => {
+    reportFatalError(err)
+    process.exit(1)
+  })
+  process.on('uncaughtException', (err) => {
+    reportFatalError(err)
+    process.exit(1)
+  })
+}
+
+module.exports = { reportFatalError, installGlobalHandlers }

package/src/ship/runner.js

@@ -8,11 +8,11 @@
  */
 
 const { spawnSync } = require('child_process')
-const fs = require('fs')
-const path = require('path')
 const { load: loadConfig, reset: resetConfig } = require('../config')
 const { resolve: forgeResolve } = require('../forge/resolve')
 const { forgeAdapter } = require('../forge/adapter')
+const validator = require('../validator')
+const { evaluateBranchIntegration, DECISION: BRANCH_PRUNE_DECISION } = require('../branch/prune')
 
 // Git subcommands that modify local or remote state.
 // In --dry-run mode these are printed but not executed.
@@ -77,66 +77,25 @@ function defaultCheckGovernance() {
 
 /**
  * checkShipGovernance — hard gate (bypasses config/baseline/lenient).
- * Checks:
- *   1. Current branch has a matching roadmap in wip/
- *   2. WIP roadmaps have a linked REQ
+ *
+ * Delegates entirely to the shared validator functions already used by `trackfw validate`,
+ * `trackfw branch new` and `trackfw commit` — never reimplement this logic locally. Byte-
+ * identical to Go's CheckShipGovernance (internal/validator/validator.go), which has the same
+ * no-args shape and the same two checks:
+ *   1. validateBranchHasWIPRoadmap — current branch (feat/fix/refactor only; re-derived
+ *      internally from TRACKFW_BRANCH/git, same as Go) has a matching roadmap in wip/ OR done/
+ *   2. validateWIPHasREQ — every roadmap in wip/ has a linked REQ
+ * Before this ML, this function reimplemented both checks locally with its own wording (no
+ * "nor done/" clause, no done/ directory scan at all) — see
+ * vault/notes/ship-checkgovernance-error-stream-wording-divergence-2026-08-16.md. Duplicating
+ * the check was the actual root cause of the drift, not just the wording.
  * @returns {string[]} violation messages
  */
 function checkShipGovernance() {
-  const violations = []
-
-  // Resolve roadmap dir via config module (single source of truth; default: docs/roadmaps)
-  const roadmapDir = resolveRoadmapDir()
-  const wipDir = path.join(roadmapDir, 'wip')
-
-  // Get branch name
-  const branchResult = defaultExecGit(['symbolic-ref', '--short', 'HEAD'])
-  const branch = branchResult.error ? '' : branchResult.stdout.trim()
-
-  // Check branch has matching roadmap in wip/ — gated types only (feat/fix/refactor); chore/docs
-  // are exempted by the outer runShip Step 2 skip and never reach this function in practice, but
-  // isGatedShipBranch keeps this check correct in isolation too.
-  if (branch && isGatedShipBranch(branch)) {
-    const slug = normalizeBranchSlug(branch.split('/').slice(1).join('/'))
-    let hasMatch = false
-    let wipFiles = []
-
-    if (fs.existsSync(wipDir)) {
-      wipFiles = fs.readdirSync(wipDir).filter(f => f.endsWith('.md'))
-      for (const f of wipFiles) {
-        if (normalizeBranchSlug(f).includes(slug)) {
-          hasMatch = true
-          break
-        }
-      }
-    }
-
-    if (wipFiles.length === 0) {
-      violations.push(
-        `branch "${branch}" is a feat/fix/refactor branch but no roadmap is in wip/ — create governance artifacts first:\n` +
-        '  trackfw req new "<title>"\n' +
-        '  trackfw roadmap new "<title>"\n' +
-        '  trackfw roadmap move <name> wip'
-      )
-    } else if (!hasMatch) {
-      violations.push(
-        `branch "${branch}" has no matching roadmap in wip/ (found: ${wipFiles.join(', ')}) — ` +
-        'include the branch slug in the roadmap filename'
-      )
-    }
-
-    // Check WIP roadmaps have a linked REQ
-    if (hasMatch && fs.existsSync(wipDir)) {
-      for (const f of wipFiles) {
-        const content = fs.readFileSync(path.join(wipDir, f), 'utf8')
-        if (!content.includes('REQ:') && !content.includes('req:')) {
-          violations.push(`roadmap "${f}" is in wip but has no linked REQ`)
-        }
-      }
-    }
-  }
-
-  return violations
+  return [
+    ...validator.validateBranchHasWIPRoadmap(),
+    ...validator.validateWIPHasREQ(),
+  ]
 }
 
 /**
@@ -172,8 +131,17 @@ function normalizeBranchSlug(value) {
 }
 
 /**
- * detectPendingSquashMerges warns about remote branches with non-empty diffs vs origin/main.
- * Non-blocking.
+ * detectPendingSquashMerges warns about remote branches with genuinely pending work vs
+ * origin/main. Non-blocking.
+ *
+ * Reuses evaluateBranchIntegration (branch/prune.js) — the same touched-files heuristic
+ * `trackfw branch prune` uses — instead of a naive bidirectional `git diff origin/main <branch>
+ * --stat`. The naive check false-positives on a branch that was squash-merged and is now merely
+ * stale (main advanced further afterwards): it always shows a non-empty diff even though nothing
+ * from the branch is actually missing from main. Only DECISION.PENDING_WORK — genuine,
+ * unintegrated work — surfaces this warning; every other decision (no_own_work,
+ * content_identical, review_doc_config, no_merge_base, eval_error) stays silent, the same
+ * posture the naive check had on error (skip, no warning).
  * @param {string} currentBranch
  * @param {function} execGit
  * @param {function} writeln
@@ -188,9 +156,8 @@ function detectPendingSquashMerges(currentBranch, execGit, writeln) {
     const shortName = candidate.replace(/^origin\//, '')
     if (shortName === currentBranch) continue
 
-    const { stdout: diff, error: derr } = execGit(['diff', 'origin/main', candidate, '--stat'])
-    if (derr) continue
-    if (diff.trim()) {
+    const evalResult = evaluateBranchIntegration(candidate, execGit)
+    if (evalResult.decision === BRANCH_PRUNE_DECISION.PENDING_WORK) {
       writeln(`Warning: branch "${shortName}" appears to have unmerged changes vs origin/main.`)
     }
   }
@@ -396,6 +363,15 @@ function runShip(opts, deps = {}) {
   const execGit = deps.execGit || defaultExecGit
   const checkGovernanceFn = deps.checkGovernance || defaultCheckGovernance
   const writeln = deps.writeln || ((s) => process.stdout.write(s + '\n'))
+  // writeErr — the terminal error line for every abort path below, written to STDERR with the
+  // "Error: " prefix. Mirrors Go exactly: ship.go returns these same messages as a bare
+  // fmt.Errorf(...), and internal/commands/root.go's Execute() wrapper prints them to stderr as
+  // `fmt.Fprintln(os.Stderr, cmd.ErrPrefix(), err.Error())` — cmd.ErrPrefix() is "Error:", and
+  // Fprintln inserts exactly one space between operands, so the wire format is
+  // "Error: <message>\n". Every multi-line detail printed BEFORE the abort (violation lists,
+  // remediation hints, "Note: ..." blocks) stays on stdout via writeln, same as Go's deps.out —
+  // only this final one-line (or one-block) summary moves to stderr.
+  const writeErr = deps.writeErr || ((s) => process.stderr.write(`Error: ${s}\n`))
 
   // Inner git wrapper: skips write commands in dry-run mode.
   function git(args) {
@@ -416,20 +392,20 @@ function runShip(opts, deps = {}) {
   // ─── Step 1: Branch validation ─────────────────────────────────────────────
   const branchResult = execGit(['symbolic-ref', '--short', 'HEAD'])
   if (branchResult.error) {
-    writeln(`error: could not determine current branch (are you in a git repo?): ${branchResult.error.message}`)
+    writeErr(`could not determine current branch (are you in a git repo?): ${branchResult.error.message}`)
     return 1
   }
   const branch = branchResult.stdout.trim()
 
   // main/master is blocked unconditionally — the doc-only exception never applies here.
   if (branch === 'main' || branch === 'master') {
-    writeln(`error: trackfw ship cannot run on "${branch}" — use a feature branch:\n  git checkout -b feat/<slug>`)
+    writeErr(`trackfw ship cannot run on "${branch}" — use a feature branch:\n  git checkout -b feat/<slug>`)
     return 1
   }
 
   if (!docOnly && !isShipBranch(branch)) {
-    writeln(
-      `error: branch "${branch}" does not match the required pattern feat|fix|refactor|chore|docs/<slug>\n` +
+    writeErr(
+      `branch "${branch}" does not match the required pattern feat|fix|refactor|chore|docs/<slug>\n` +
       'Rename your branch or create a new one:\n  git checkout -b feat/<slug>'
     )
     return 1
@@ -461,7 +437,7 @@ function runShip(opts, deps = {}) {
       writeln("mode or per-rule severity configured in trackfw.yaml. If 'trackfw validate'")
       writeln("passes but 'trackfw ship' aborts here, you likely have lenient mode")
       writeln("configured — ship always requires REQ + roadmap in wip/.")
-      writeln(`\nerror: governance check failed: ${violations.length} violation(s)`)
+      writeErr(`governance check failed: ${violations.length} violation(s)`)
       return 1
     }
 
@@ -491,8 +467,8 @@ function runShip(opts, deps = {}) {
 
   // Reuses stagedFiles read at the top of the function (Step 0) — never re-query git here.
   if (stagedFiles.length === 0) {
-    writeln(
-      'error: nothing is staged — stage your files explicitly before running ship:\n' +
+    writeErr(
+      'nothing is staged — stage your files explicitly before running ship:\n' +
       '  git add <file1> <file2> ...\n' +
       "Never use 'git add .' or 'git add -A'"
     )
@@ -501,8 +477,8 @@ function runShip(opts, deps = {}) {
 
   // ─── Step 5: Commit ────────────────────────────────────────────────────────
   if (!opts.message) {
-    writeln(
-      'error: commit message is required — use -m:\n' +
+    writeErr(
+      'commit message is required — use -m:\n' +
       '  trackfw ship -m "feat(<scope>): <description>"'
     )
     return 1
@@ -510,7 +486,7 @@ function runShip(opts, deps = {}) {
 
   const { error: commitErr } = git(['commit', '-m', opts.message])
   if (commitErr) {
-    writeln(`error: git commit failed: ${commitErr.message}`)
+    writeErr(`git commit failed: ${commitErr.message}`)
     return 1
   }
 
@@ -522,7 +498,7 @@ function runShip(opts, deps = {}) {
   const pushArgs = buildPushArgs(branch, execGit)
   const { error: pushErr } = git(pushArgs)
   if (pushErr) {
-    writeln(`error: git push failed: ${pushErr.message}`)
+    writeErr(`git push failed: ${pushErr.message}`)
     return 1
   }
 
@@ -638,4 +614,5 @@ module.exports = {
   gitCommitsSince,
   buildPRBody,
   COMMIT_MESSAGE_SEP,
+  detectPendingSquashMerges,
 }