@skitterbyte/skitterspec-jira 0.0.0-stage → 1.0.0

package/src/vendor/provider-kit/src/md-tables.js

@@ -0,0 +1,94 @@
+'use strict'
+
+/**
+ * Flatten markdown tables that sit INSIDE a list item, because both tracker
+ * dialects need it: Linear's renderer corrupts nested-table data cells
+ * (measured on probe SKI-28, 2026-08-28 — every data cell loses its first N
+ * characters, N being the rendered list indent; the auth header
+ * `X-Extraction-Key` was stored as `Extraction-Key`), and ADF's `listItem`
+ * cannot contain a `table` node at all, so a Jira render would drop or mangle
+ * it. The re-emitted shapes are ones proven to survive nesting unchanged:
+ *
+ *   - 2 columns  → a bullet list (`- a — b`), the key/value case
+ *   - otherwise  → a fenced code block wrapping the original rows verbatim
+ *
+ * This shapes the PROJECTION only. Repo files are never rewritten: the source
+ * markdown is valid and renders correctly in GitHub and every editor.
+ */
+
+const { fenceMask } = require('../../sync-core/src/task-block.js')
+
+// A table row: optional indent, then a `|`-delimited line. We only ever act on
+// indented ones — a column-0 table (the `## Phases` index, every Impact map) is
+// rendered correctly by Linear and must project byte-identically.
+const ROW_RE = /^([ \t]+)\|(.*)\|[ \t]*$/
+// The separator under the header — `|---|:--:|`. Its presence is what makes the
+// block a table rather than prose that happens to contain pipes.
+const SEPARATOR_RE = /^[ \t]+\|[\s:|-]+\|[ \t]*$/
+
+// Split a row into cells on pipes that are OUTSIDE an inline-code span, so a
+// documented `` `a | b` `` alternation stays one cell instead of splitting.
+function splitCells(body) {
+  const cells = []
+  let cur = ''
+  let code = false
+  for (const ch of body) {
+    if (ch === '`') code = !code
+    if (ch === '|' && !code) {
+      cells.push(cur.trim())
+      cur = ''
+      continue
+    }
+    cur += ch
+  }
+  cells.push(cur.trim())
+  return cells
+}
+
+/**
+ * Rewrite every indented table in `md`. Returns the text unchanged when there is
+ * nothing nested to flatten.
+ * @param {string} md
+ * @returns {string}
+ */
+function flattenNestedTables(md) {
+  if (md == null) return md
+  const lines = String(md).split('\n')
+  const inFence = fenceMask(lines)
+  const out = []
+
+  for (let i = 0; i < lines.length; i++) {
+    const header = ROW_RE.exec(lines[i])
+    // A table shown as an EXAMPLE inside a ``` block is documentation — often of
+    // this very bug — so it is left exactly as written.
+    if (!header || inFence[i] || !SEPARATOR_RE.test(lines[i + 1] || '')) {
+      out.push(lines[i])
+      continue
+    }
+
+    const indent = header[1]
+    const rows = [splitCells(header[2])]
+    const raw = [lines[i], lines[i + 1]]
+    let j = i + 2
+    for (; j < lines.length && !inFence[j]; j++) {
+      const row = ROW_RE.exec(lines[j])
+      if (!row) break
+      rows.push(splitCells(row[2]))
+      raw.push(lines[j])
+    }
+
+    if (rows[0].length === 2) {
+      // Header first, bolded: dropping it would lose content and inventing a
+      // caption would invent it.
+      out.push(`${indent}- **${rows[0][0]}** — **${rows[0][1]}**`)
+      for (const r of rows.slice(1)) out.push(`${indent}- ${r[0]} — ${r[1]}`)
+    } else {
+      out.push(`${indent}\`\`\``, ...raw, `${indent}\`\`\``)
+    }
+    i = j - 1
+  }
+  return out.join('\n')
+}
+
+
+module.exports = { flattenNestedTables, splitCells }

package/src/vendor/provider-kit/src/prompt.js

@@ -0,0 +1,50 @@
+'use strict'
+
+/**
+ * Terminal input helpers for a credentials CLI — reading a piped secret, and
+ * prompting for one with the echo off.
+ */
+
+// Read stdin to completion (for `--stdin`).
+function readAllStdin(input) {
+  return new Promise((resolve, reject) => {
+    let data = ''
+    input.setEncoding('utf-8')
+    input.on('data', (chunk) => (data += chunk))
+    input.on('end', () => resolve(data))
+    input.on('error', reject)
+  })
+}
+
+// Prompt on a TTY with the input hidden. `_writeToOutput` is readline's own echo
+// hook — filtering it is what keeps the key off the screen (and out of a
+// screen-shared terminal or a recorded session).
+//
+// READLINE OWNS THE PROMPT, deliberately. Writing it ourselves and then starting
+// the interface loses it: readline clears from the cursor to the end of the
+// screen (`ESC[0J`) before its first redraw, so the prompt was wiped the instant
+// it appeared and the user was left staring at a blank line while the process
+// waited for a key — indistinguishable from a hang.
+//
+// The hook is assigned BEFORE `question`, so the very first redraw goes through
+// it. readline hands it `prompt + what has been typed`; re-writing only the
+// prompt is what keeps the key hidden while the prompt survives every redraw.
+function promptHidden(question, input, out) {
+  const readline = require('node:readline')
+  return new Promise((resolve) => {
+    // `out`, never `process.stdout`: they are the same stream in production, and
+    // hardcoding one half meant readline cleared a screen the prompt had not
+    // been written to under test — the split that hid this bug from the suite.
+    const rl = readline.createInterface({ input, output: out, terminal: true })
+    rl._writeToOutput = (s) => {
+      if (s.includes(question)) out.write(question)
+    }
+    rl.question(question, (answer) => {
+      out.write('\n')
+      rl.close()
+      resolve(answer)
+    })
+  })
+}
+
+module.exports = { readAllStdin, promptHidden }

package/src/vendor/provider-kit/src/released.js

@@ -0,0 +1,226 @@
+'use strict'
+
+/**
+ * Which tickets a release contains.
+ *
+ * The repo lands specs with `merge --ff-only`, so history is linear and branch
+ * names never reach it. A commit's `Refs:` trailer is therefore the only place
+ * the ticket survives into the range a release scans — see the
+ * `commit-trailers` rule. Nothing here is tracker-specific: the identifier
+ * shape (`KEY-123`) and the team-key prefix are common to the trackers this
+ * scans for, which is why the module lives in the kit.
+ *
+ * The parsing half is pure and takes commits as data, so the rules below are
+ * testable without git. Reading the range, and enriching refs with issue titles,
+ * belong to the caller.
+ */
+
+// An issue identifier: uppercase team key, dash, number.
+const IDENTIFIER_RE = /\b[A-Z][A-Z0-9]*-\d+\b/g
+// A `Refs:` trailer line. Anchored, so it is a line of its own — never prose
+// that happens to mention the word.
+const TRAILER_RE = /^Refs:[ \t]*(.+?)[ \t]*$/
+
+/**
+ * The refs a single commit body claims.
+ *
+ * Deliberately blind to three things that LOOK like trailers and are not:
+ *
+ *   - a line inside a ``` fence — a commit explaining the convention quotes it;
+ *   - a quoted line (`> Refs: …`) — same reason, in review replies;
+ *   - an indented line (4+ spaces) — markdown code, e.g. a sample message.
+ *
+ * Counting any of those would make a release claim work it does not contain,
+ * which is worse than missing a ticket: the missing one is noticed when someone
+ * looks for it, the invented one never is.
+ */
+function refsInBody(body) {
+  const found = []
+  let fenced = false
+  for (const raw of String(body || '').split('\n')) {
+    const line = raw.replace(/\r$/, '')
+    if (/^\s*```/.test(line)) {
+      fenced = !fenced
+      continue
+    }
+    if (fenced) continue
+    if (/^\s*>/.test(line)) continue
+    if (/^ {4,}|\t/.test(line)) continue
+    const m = TRAILER_RE.exec(line.trim() === line ? line : line.trimStart())
+    if (!m) continue
+    for (const id of m[1].match(IDENTIFIER_RE) || []) found.push(id)
+  }
+  return found
+}
+
+/**
+ * Whether a commit's changed paths are ENTIRELY bookkeeping.
+ *
+ * The problem it solves: a spec's `chore(spec): complete <name>` commit carries
+ * the same `Refs:` trailer as the code it describes, but lands after the tag
+ * that shipped that code — so the ticket turns up in two consecutive release
+ * ranges, once for its code and once for its paperwork.
+ *
+ * Deliberately a POSITIVE signal: it says yes only when it actually saw paths
+ * and every one of them sits under an ignored prefix. It never reasons from an
+ * absence.
+ *
+ * WHAT WOULD FOOL THE OTHER PHRASING ("no unignored path was found"): git lists
+ * no files at all for a MERGE commit (without `-m`) — verified, not assumed —
+ * nor for a genuinely empty one, and a `git log` that failed outright yields no
+ * paths for anything. Under that phrasing every one of those becomes a release
+ * silently losing its tickets. Under this one they mean "nothing was seen, so
+ * nothing is known", which keeps the pre-filter behaviour: an over-claimed
+ * ticket is noticed when someone looks for it, whereas a ticket that quietly
+ * belongs to no release never is.
+ *
+ * Matching is path-prefix, not glob: `specs` and `specs/` both mean the
+ * directory, and a prefix only matches on a path SEGMENT boundary, so `specs/`
+ * never swallows `specs-archive/`.
+ *
+ * @param {string[]|null|undefined} paths repo-relative paths the commit changed
+ * @param {string[]} ignorePaths repo-relative prefixes that are bookkeeping
+ */
+function onlyIgnoredPaths(paths, ignorePaths) {
+  if (!Array.isArray(paths) || !paths.length) return false
+  const prefixes = (Array.isArray(ignorePaths) ? ignorePaths : [])
+    .filter((p) => typeof p === 'string' && p.trim())
+    .map((p) => p.trim().replace(/^\.\//, '').replace(/\/+$/, ''))
+    .filter(Boolean)
+  if (!prefixes.length) return false
+  return paths.every((raw) => {
+    const file = String(raw == null ? '' : raw)
+      .trim()
+      .replace(/^\.\//, '')
+    // An unreadable entry is an unknown, not an ignored one — it makes the whole
+    // commit count, per the bias above.
+    if (!file) return false
+    return prefixes.some((prefix) => file === prefix || file.startsWith(`${prefix}/`))
+  })
+}
+
+/**
+ * Fold commits into the report a release needs.
+ *
+ * @param {Array<{sha?:string, subject?:string, body?:string, paths?:string[]}>} commits
+ * @param {{ignorePaths?:string[]}} [options] `ignorePaths` marks bookkeeping —
+ *   see `onlyIgnoredPaths`. Omitted (or empty) means nothing is ignored, so the
+ *   report is what it was before the filter existed.
+ * @returns {{tickets: Array<{ref:string, commits:number}>, unreferenced:number, ignored:number, total:number}}
+ *   `tickets` is deduped in FIRST-SEEN order: a ticket touched by eight commits
+ *   is listed once, where it first appears, not eight times. `ignored` is
+ *   reported rather than merely subtracted — a filter that removes commits in
+ *   silence reads as "there was nothing there".
+ */
+function ticketsInRange(commits, options = {}) {
+  const ignorePaths = (options && options.ignorePaths) || []
+  const seen = new Map()
+  let unreferenced = 0
+  let ignored = 0
+  for (const commit of commits || []) {
+    if (onlyIgnoredPaths(commit && commit.paths, ignorePaths)) {
+      // Not counted as unreferenced either: that number exists to surface a
+      // MISSED trailer, and a paperwork commit is not a gap someone should hunt.
+      ignored++
+      continue
+    }
+    const refs = [...new Set(refsInBody(commit && commit.body))]
+    if (!refs.length) {
+      unreferenced++
+      continue
+    }
+    for (const ref of refs) seen.set(ref, (seen.get(ref) || 0) + 1)
+  }
+  return {
+    tickets: [...seen.entries()].map(([ref, count]) => ({ ref, commits: count })),
+    unreferenced,
+    ignored,
+    total: (commits || []).length,
+  }
+}
+
+/**
+ * Split a release's tickets into the ones a stage move may touch and the ones it
+ * must not, with a reason for every exclusion.
+ *
+ * Three reasons to leave a ticket alone, and each is a case where acting would
+ * be worse than not acting:
+ *
+ *   - **foreign** — the ref is not this repo's team. A range can carry another
+ *     team's ref (a shared dependency, a quoted ticket), and writing to a team
+ *     this repo was never configured for is the worst failure available here.
+ *   - **unlinked** — the ref is this team's, but no spec in the repo claims it.
+ *     It may be tracker-only work, or a typo in a trailer. Either way nothing
+ *     here knows what it is, so it is reported, not moved.
+ *   - **unfinished** — a spec that has not reached the ceded bucket. Its code
+ *     really is in the release (it landed via `/spec-to-main`), but push still
+ *     owns its workflow state and would bounce it straight back. Exactly one
+ *     writer per issue at any moment beats a visible flip-flop.
+ *
+ * Pure: it takes the spec list as data, so the rules are testable without a repo.
+ */
+function partitionStageMoves({ tickets, teamKey, specs, cededBucket = 'complete' }) {
+  const bucketOf = new Map()
+  for (const spec of specs || []) {
+    if (spec && spec.identifier) bucketOf.set(spec.identifier, spec.bucket)
+  }
+  const key = String(teamKey || '').trim().toUpperCase()
+  const movable = []
+  const foreign = []
+  const unlinked = []
+  const unfinished = []
+  for (const ticket of tickets || []) {
+    const ref = ticket && ticket.ref
+    if (!ref) continue
+    if (key && !ref.toUpperCase().startsWith(`${key}-`)) {
+      foreign.push(ticket)
+    } else if (!bucketOf.has(ref)) {
+      unlinked.push(ticket)
+    } else if (bucketOf.get(ref) !== cededBucket) {
+      unfinished.push({ ...ticket, bucket: bucketOf.get(ref) })
+    } else {
+      movable.push(ticket)
+    }
+  }
+  return { movable, foreign, unlinked, unfinished }
+}
+
+/**
+ * Whether moving from `fromState` to the rung `toKey` runs against the declared
+ * order — and if so, how to say it.
+ *
+ * WARNS, never refuses. A rollback from test and a hotfix going straight to prod
+ * are both legitimate, and a check that blocked either would be wrong on healthy
+ * input. An issue that is on no rung yet is entering the ladder, which is the
+ * normal case and says nothing.
+ *
+ * `lifecycleStates` is the bucket map's own state names, and a state among them
+ * means the issue is at its LIFECYCLE position, not on a rung — even when the
+ * two names coincide. They routinely do: `states.complete` and a final `prod`
+ * rung are both naturally "Done", and without this a spec that had merely been
+ * completed would read as already deployed to prod, so its first real deploy
+ * would be warned about as a move backwards. Bucket wins over ladder here for
+ * the same reason it wins in `bucketForState`.
+ *
+ * @returns {string|null}
+ */
+function stageOrderWarning(stages, fromState, toKey, lifecycleStates = []) {
+  const list = Array.isArray(stages) ? stages : []
+  const to = list.findIndex((s) => s && s.key === toKey)
+  if (to < 0) return null
+  const want = String(fromState || '').toLowerCase().trim()
+  if (!want) return null
+  const lifecycle = new Set(
+    (Array.isArray(lifecycleStates) ? lifecycleStates : [])
+      .filter((n) => typeof n === 'string')
+      .map((n) => n.toLowerCase().trim()),
+  )
+  if (lifecycle.has(want)) return null
+  const from = list.findIndex((s) => s && typeof s.state === 'string' && s.state.toLowerCase().trim() === want)
+  if (from < 0) return null
+  if (to < from) return `moves back from "${list[from].key}"`
+  if (to > from + 1) return `skips ${to - from - 1} rung(s) from "${list[from].key}"`
+  return null
+}
+
+module.exports = { ticketsInRange, refsInBody, onlyIgnoredPaths, partitionStageMoves, stageOrderWarning }

package/src/vendor/provider-kit/src/specs.js

@@ -0,0 +1,166 @@
+'use strict'
+
+/**
+ * Spec resolution and listing for a provider CLI — how a spec argument becomes
+ * a snapshot directory, how a spec names its snapshot sidecar, and which specs
+ * a repo holds with which tracker links.
+ *
+ * The frontmatter key that links a spec is the provider's
+ * (`config.fields.identifier` — sync-core `src/fields.js`); everything else
+ * here is filesystem shape shared by every provider. `program` prefixes the
+ * user-facing refusals (`spec-sync: spec not found: …`).
+ */
+
+const fs = require('node:fs')
+const path = require('node:path')
+
+const { BUCKETS, findSpecFolder } = require('../../../env/resolve.js')
+const { readSnapshot, parseFrontmatter, lintPhases, fieldsOf, projectionOf, compareStored } = require('../../sync-core')
+
+function makeSpecHelpers({ program = 'spec-sync' } = {}) {
+  // Resolve a spec argument to its snapshot dir. Accepts a spec name/folder
+  // found under specs/** (preferred) or a literal path to a snapshot directory.
+  function resolveSnapshotDir(specArg, dir) {
+    const found = findSpecFolder(specArg, dir)
+    if (found) return found.path
+    const literal = path.resolve(dir, specArg)
+    if (fs.existsSync(literal) && fs.statSync(literal).isDirectory()) return literal
+    return null
+  }
+
+  // The identifier keying the snapshot sidecar: the spec's stamped identifier
+  // if set, else its folder name (so the engine is usable before a spec is
+  // linked).
+  function specIdentifier(snapshotDir, config) {
+    const field = fieldsOf(config).identifier
+    try {
+      const { frontmatter } = readSnapshot(snapshotDir, config)
+      if (frontmatter[field]) return String(frontmatter[field])
+    } catch {
+      /* fall through to folder name */
+    }
+    return path.basename(snapshotDir)
+  }
+
+  // Read a spec's stamped identifier without throwing: an unlinked spec, an
+  // unreadable file and a spec with no frontmatter all read as `null`.
+  function linkedIdentifier(overviewPath, config) {
+    const field = fieldsOf(config).identifier
+    let raw
+    try {
+      raw = fs.readFileSync(overviewPath, 'utf-8')
+    } catch {
+      return null
+    }
+    const { data } = parseFrontmatter(raw)
+    return data[field] ? String(data[field]) : null
+  }
+
+  // Every spec under specs/<bucket>/, paired with the tracker issue it is
+  // linked to (`null` when it has never been pushed). Folder specs read
+  // `snapshot.overviewFile`; legacy bare `<name>.md` specs read the file
+  // itself. Sorted for stable output.
+  function listSpecs(dir, config) {
+    const overviewFile = (config.snapshot && config.snapshot.overviewFile) || '00-overview.md'
+    const specs = []
+    for (const bucket of BUCKETS) {
+      const root = path.join(dir, 'specs', bucket)
+      let entries
+      try {
+        entries = fs.readdirSync(root, { withFileTypes: true })
+      } catch {
+        continue
+      }
+      for (const entry of entries) {
+        let name
+        let overviewPath
+        if (entry.isDirectory()) {
+          name = entry.name
+          overviewPath = path.join(root, name, overviewFile)
+        } else if (entry.isFile() && entry.name.endsWith('.md')) {
+          name = entry.name.slice(0, -3)
+          overviewPath = path.join(root, entry.name)
+        } else {
+          continue
+        }
+        specs.push({ spec: name, bucket, identifier: linkedIdentifier(overviewPath, config) })
+      }
+    }
+    return specs.sort((a, b) => a.spec.localeCompare(b.spec))
+  }
+
+  // Resolve a spec argument to its folder, or null with a message on stdout.
+  // EVERY failure path here must print and EVERY caller must return a non-zero
+  // code: a push skill checks $? before it applies a plan, so a resolve failure
+  // that exits 0 reads as "nothing to do" rather than "I could not find the
+  // spec".
+  function resolveOrExit(specArg, dir, out) {
+    if (!specArg) {
+      out.write(`${program}: no spec given\n`)
+      return null
+    }
+    const snapshotDir = resolveSnapshotDir(specArg, dir)
+    if (!snapshotDir) {
+      out.write(`${program}: spec not found: ${specArg}\n`)
+      return null
+    }
+    return snapshotDir
+  }
+
+  // Phase-status warnings for a spec, one formatted line each. A spec states
+  // each phase's status three times and only the h1 emoji is read — get it
+  // wrong and the phase projects as `backlog`, pushes cleanly, and is recorded
+  // as intended: invisible. Reported by every subcommand that reads a
+  // projection, fatal in none — a legacy spec must still push.
+  function warningLines(snapshotDir, config) {
+    return lintPhases(snapshotDir, config).map((w) => `  warning ${w.file}: ${w.message}`)
+  }
+
+  // Emit warnings on stderr, keeping stdout pure for a machine-readable payload.
+  function warnToErr(snapshotDir, config, err) {
+    const lines = warningLines(snapshotDir, config)
+    if (lines.length) err.write(lines.join('\n') + '\n')
+  }
+
+  // Render the read-back comparison — the same check `verify` and `apply`
+  // both report through, so the two cannot disagree about what "intact" means.
+  function verifyLines(snapshotDir, config, stored, identifier) {
+    const projection = projectionOf(snapshotDir, config)
+    const checks = []
+    if (typeof stored.issue === 'string') checks.push(['issue', projection.description, stored.issue])
+    for (const [ref, text] of Object.entries(stored.subIssues || {})) {
+      const sub = projection.subIssues.find((s) => s.ref === ref)
+      if (!sub) {
+        checks.push([`sub-issue ${ref}`, null, text])
+        continue
+      }
+      checks.push([`sub-issue ${ref}`, sub.goal, text])
+    }
+
+    const lines = [`${program} verify: ${identifier}`]
+    let bad = 0
+    for (const [label, sent, got] of checks) {
+      if (sent == null) {
+        lines.push(`  ?? ${label}: read back, but the projection has no such phase — stale ref?`)
+        bad++
+        continue
+      }
+      const r = compareStored(sent, got, config)
+      if (r.ok) continue
+      bad++
+      lines.push(
+        `  !! ${label}: the tracker stored different text — ${Math.abs(r.lost)} character(s) ` +
+          `${r.lost > 0 ? 'lost' : 'added'}, first difference at ${r.at}`,
+        `     sent:   …${r.sentContext}…`,
+        `     stored: …${r.storedContext}…`,
+      )
+    }
+    if (!bad) lines.push(`  ${checks.length} description(s) round-tripped intact`)
+    else lines.push('     the repo is unchanged and still correct; re-push to overwrite the mirror')
+    return lines
+  }
+
+  return { resolveSnapshotDir, specIdentifier, linkedIdentifier, listSpecs, resolveOrExit, warningLines, warnToErr, verifyLines }
+}
+
+module.exports = { makeSpecHelpers }

package/src/vendor/provider-kit/src/transport.js

@@ -0,0 +1,22 @@
+'use strict'
+
+/**
+ * Which transport a command runs over: `--via` wins, else the config's
+ * declared default, else "api when a credential resolved, mcp when it didn't".
+ *
+ * This expression was repeated verbatim nine times in the first provider —
+ * hoisted so the precedence is decided once. Per-command DEGRADATION stays with
+ * the command: which operations are impossible over mcp (exit 1, say so) and
+ * which hand the skill instructions (exit 0) is a per-command judgment, not a
+ * transport fact.
+ */
+
+function resolveTransport(flags, config, credentialOk) {
+  return (
+    (flags && flags.via) ||
+    (config && config.apply && config.apply.transport) ||
+    (credentialOk ? 'api' : 'mcp')
+  )
+}
+
+module.exports = { resolveTransport }

package/src/vendor/sync-core/index.js

@@ -0,0 +1,92 @@
+'use strict'
+
+/**
+ * Provider-neutral one-way sync engine (repo → tracker).
+ *
+ * Every function is parameterised by a plain `config` object — it knows nothing
+ * about any specific tracker. The repo is the source of truth: the engine builds
+ * a local projection, diffs it against a committed last-pushed snapshot
+ * (`planChanges`), and returns a create/update plan the provider skill applies
+ * over its API. No remote content is read for CONTENT: nothing the tracker holds
+ * ever feeds the projection, the snapshot, or a repo file. `compareStored` is the
+ * one function that looks at a tracker value, and it only checks that what was
+ * stored matches what was sent — it merges nothing (see `src/verify.js`).
+ */
+
+const { ownsField, normalizeLocal, LIFECYCLE_BUCKETS, lintPhases, readSnapshot, parseFrontmatter, remoteWorkflowState, titleFromText, validateStates, stateSuggestions, stageForState, remoteStage, phaseModeFor, LADDER_ORIGIN_BUCKET } = require('./src/normalize.js')
+const { planChanges, snapshotOf, isEmptyPlan, hashField, stableStringify, remoteDescriptionEdited } = require('./src/compare.js')
+const { readBase, writeBase } = require('./src/base.js')
+const { push, recordPush, projectionOf } = require('./src/push.js')
+const { writeFrontmatter, deleteFrontmatter, stampSubIssueId, stampIssueId, findPhaseFileByTitle, listPhaseFiles } = require('./src/write.js')
+const { detectLegacyMirror } = require('./src/legacy.js')
+const { compareStored, stream } = require('./src/verify.js')
+const { identityDialect, dialectOf } = require('./src/dialect.js')
+const { fieldsOf } = require('./src/fields.js')
+const { renderTaskBlock, findTaskBlocks, wrapEmphasisAware, collapseHyphenAware, inferWidth, fenceMask, DEFAULT_WIDTH } = require('./src/task-block.js')
+const { planRetarget, applyRetarget, deriveRecordedKey, isEmptyRetarget, dirtyPaths } = require('./src/retarget.js')
+
+module.exports = {
+  ownsField,
+  normalizeLocal,
+  // Exported for `spec-sync list`: an `inline`-mode spec has no phase sub-issues
+  // to read, so the listing must resolve the mode rather than assume `subissue`.
+  phaseModeFor,
+  lintPhases,
+  readSnapshot,
+  parseFrontmatter,
+  projectionOf,
+  planChanges,
+  snapshotOf,
+  isEmptyPlan,
+  push,
+  recordPush,
+  remoteWorkflowState,
+  titleFromText,
+  validateStates,
+  stateSuggestions,
+  stageForState,
+  remoteStage,
+  LADDER_ORIGIN_BUCKET,
+  hashField,
+  stableStringify,
+  readBase,
+  writeBase,
+  writeFrontmatter,
+  deleteFrontmatter,
+  stampSubIssueId,
+  stampIssueId,
+  findPhaseFileByTitle,
+  listPhaseFiles,
+  detectLegacyMirror,
+  compareStored,
+  // The tolerant reduction behind both `compareStored` and the snapshot's
+  // `descriptionStream` hash — exported so a provider can reduce a read-back the
+  // same way rather than writing a second one that disagrees.
+  stream,
+  // Did someone else edit the tracker's description since the last push?
+  // Three-valued; `null` is cannot-tell and must never be reported as drift.
+  remoteDescriptionEdited,
+  // Provider seams: the frontmatter field vocabulary and the markdown dialect
+  // a provider's config supplies (`config.fields` / `config.dialect`).
+  fieldsOf,
+  identityDialect,
+  dialectOf,
+  // The lifecycle buckets, exported once so providers and tests stop growing
+  // private copies (the tracker-free common package keeps its own — it cannot
+  // depend on this package).
+  LIFECYCLE_BUCKETS,
+  // Task-block helpers a provider's own text tooling builds on (the Linear
+  // sanitiser reflows emphasis-aware with these).
+  renderTaskBlock,
+  findTaskBlocks,
+  wrapEmphasisAware,
+  collapseHyphenAware,
+  inferWidth,
+  fenceMask,
+  DEFAULT_WIDTH,
+  planRetarget,
+  applyRetarget,
+  deriveRecordedKey,
+  isEmptyRetarget,
+  dirtyPaths,
+}