rvlib-shipkit 1.9.0 → 2.0.1

package/src/prose/ste.ts

@@ -1,552 +0,0 @@
-// STE prose checker — the mechanical subset of ASD-STE100 (Issue 9) that a
-// machine can judge without reading for meaning. The standard has 53 rules
-// and a ~900-word dictionary; this file implements the classes where a regex
-// is not a guess, and stays silent everywhere else. The house standard and
-// the exemptions: identity/writing-voice.md.
-//
-// Three tiers, because the cost of being wrong is not the same for each:
-//   fix  — one mechanical rewrite, meaning preserved. `--fix` applies it.
-//   hard — a real violation whose repair is a judgement call. Reported.
-//   soft — needs a human read (length, voice). Warns, never blocks alone.
-//
-// The class ids are STABLE: a baseline count and a `steAllow` entry both
-// name them.
-
-export type ProseTier = 'fix' | 'hard' | 'soft'
-
-export type ProseClass =
-    | 'contraction'
-    | 'abbrev'
-    | 'slop'
-    | 'modal'
-    | 'semicolon'
-    | 'comma-ing'
-    | 'perfect'
-    | 'vague'
-    | 'sentence'
-    | 'passive'
-    | 'paragraph'
-    | 'ban'
-
-export type ProseHit = {
-    line: number // 1-based, true to the file
-    start: number // offset into the source
-    end: number
-    cls: ProseClass
-    tier: ProseTier
-    text: string // the offending span
-    fix?: string // the replacement, when the class is mechanical
-    why: string // one line, what STE wants instead
-    /** the dictionary entry that fired, lowercased: what a repo `allow` entry
-     *  names and what the hub groups by. Absent on the classes that judge a
-     *  shape (sentence length, paragraph, semicolon) rather than a word */
-    word?: string
-}
-
-/** a word or phrase this repo accepts: every hit on it is dropped */
-export type ProseAllowWord = {
-    /** the word or phrase, case ignored. A dictionary entry (`should`,
-     *  `leverage`) covers its inflected forms too */
-    word: string
-    /** one line: why this repo accepts it */
-    reason?: string
-}
-
-/** a word or phrase this repo refuses on top of the house dictionary */
-export type ProseBanWord = {
-    /** the word or phrase, case ignored, matched on word boundaries */
-    word: string
-    /** what to write instead. Given, `shipkit prose --fix` writes it */
-    to?: string
-    /** one line: why this repo refuses it */
-    reason?: string
-}
-
-/** the per repo word lists. The house dictionary in this file stays the
- *  default, and these override it for one repo only */
-export type ProseWords = {
-    /** words and phrases this repo accepts */
-    allow?: ProseAllowWord[]
-    /** words and phrases this repo refuses, each with its replacement */
-    ban?: ProseBanWord[]
-}
-
-export type ProseOpts = {
-    /** class ids this file or repo does not want checked */
-    allow?: ProseClass[]
-    /** procedural limit (20) instead of the descriptive one (25) */
-    strict?: boolean
-    /** the repo's own allow and ban lists */
-    words?: ProseWords
-}
-
-const TIER: Record<ProseClass, ProseTier> = {
-    contraction: 'fix',
-    abbrev: 'fix',
-    slop: 'fix',
-    modal: 'soft',
-    // reports, never blocks: the join carries meaning a rewrite can lose
-    semicolon: 'soft',
-    'comma-ing': 'soft',
-    perfect: 'soft',
-    vague: 'hard',
-    sentence: 'soft',
-    passive: 'soft',
-    paragraph: 'soft',
-    // the repo named the word itself, so a hit is never a guess
-    ban: 'hard',
-}
-
-export const PROSE_CLASSES = Object.keys(TIER) as ProseClass[]
-export const tierOf = (c: ProseClass): ProseTier => TIER[c]
-
-// --- vocabulary tables ---------------------------------------------------
-
-/** contractions → the full form. STE keeps every word a reader can look up. */
-const CONTRACTIONS: Record<string, string> = {
-    "aren't": 'are not', "can't": 'cannot', "couldn't": 'could not', "didn't": 'did not',
-    "doesn't": 'does not', "don't": 'do not', "hadn't": 'had not', "hasn't": 'has not',
-    "haven't": 'have not', "isn't": 'is not', "mustn't": 'must not', "shouldn't": 'should not',
-    "wasn't": 'was not', "weren't": 'were not', "won't": 'will not', "wouldn't": 'would not',
-    "he's": 'he is', "here's": 'here is', "it's": 'it is', "let's": 'let us', "she's": 'she is',
-    "that's": 'that is', "there's": 'there is', "they're": 'they are', "they've": 'they have',
-    "we're": 'we are', "we've": 'we have', "what's": 'what is', "who's": 'who is',
-    "you're": 'you are', "you've": 'you have', "i'm": 'I am', "we'll": 'we will',
-    "you'll": 'you will', "it'll": 'it will', "they'll": 'they will',
-}
-
-/** latin and shorthand a non-native reader must decode */
-const ABBREV: Record<string, string> = {
-    'e.g.': 'for example', 'i.e.': 'that is', 'vs.': 'against', 'w/': 'with',
-}
-
-/** one mechanical replacement, meaning preserved. Sourced from the STE
- *  dictionary's not-approved column where the alternative is unambiguous,
- *  plus the AI-slop words rule 1.5 (keep it short) covers.
- *  `verb: true` lets the checker carry the inflection across, so `utilizes`
- *  becomes `uses` and not `utilizes`. Without it a table of base forms
- *  silently misses most real prose. */
-const SUBSTITUTIONS: { from: string; to: string; verb?: boolean }[] = [
-    { from: 'leverage', to: 'use', verb: true },
-    { from: 'utilize', to: 'use', verb: true },
-    { from: 'commence', to: 'start', verb: true },
-    { from: 'terminate', to: 'stop', verb: true },
-    { from: 'obtain', to: 'get', verb: true },
-    { from: 'facilitate', to: 'help', verb: true },
-    { from: 'streamline', to: 'make simpler', verb: false },
-    { from: 'prior to', to: 'before' },
-    { from: 'in order to', to: 'to' },
-    { from: 'due to the fact that', to: 'because' },
-    { from: 'in the event that', to: 'if' },
-    { from: 'out of the box', to: 'by default' },
-    { from: 'under the hood', to: 'internally' },
-    { from: 'a number of', to: 'some' },
-    { from: 'is able to', to: 'can' },
-    { from: 'are able to', to: 'can' },
-    { from: 'has the ability to', to: 'can' },
-    { from: 'plethora', to: 'many' },
-    { from: 'myriad', to: 'many' },
-    { from: 'additionally', to: 'also' },
-    { from: 'furthermore', to: 'also' },
-    { from: 'moreover', to: 'also' },
-]
-
-/** carry an English verb inflection from the banned word onto its
- *  replacement. Only the four regular endings, because an irregular form is
- *  a guess and this table exists to avoid guesses. */
-const IRREGULAR: Record<string, Record<string, string>> = {
-    get: { s: 'gets', es: 'gets', d: 'got', ed: 'got', ing: 'getting' },
-    stop: { s: 'stops', es: 'stops', d: 'stopped', ed: 'stopped', ing: 'stopping' },
-    run: { s: 'runs', es: 'runs', d: 'ran', ed: 'ran', ing: 'running' },
-}
-
-function inflect(base: string, suffix: string): string {
-    if (suffix === '') return base
-    const irr = IRREGULAR[base]?.[suffix]
-    if (irr != null) return irr
-    if (suffix === 's' || suffix === 'es') return /(s|x|z|ch|sh)$/.test(base) ? `${base}es` : `${base}s`
-    if (suffix === 'd' || suffix === 'ed') return base.endsWith('e') ? `${base}d` : `${base}ed`
-    if (suffix === 'ing') return base.endsWith('e') ? `${base.slice(0, -1)}ing` : `${base}ing`
-    return base
-}
-
-/** the same idea where the replacement must eat neighbouring punctuation.
- *  'However, X' becomes 'But X', never 'But, X'. */
-const PHRASE_SUBSTITUTIONS: { re: RegExp; to: string; why: string }[] = [
-    { re: /\bhowever,\s+/gi, to: 'but ', why: "STE writes 'but'" },
-    { re: /\bnevertheless,\s+/gi, to: 'but ', why: "STE writes 'but'" },
-    { re: /\bnonetheless,\s+/gi, to: 'but ', why: "STE writes 'but'" },
-]
-
-/** deletable: the word carries no fact, and removing it leaves valid grammar.
- *  Intensifiers are deliberately NOT here. `very` is an approved STE word, and
- *  an intensifier a writer chose states a degree, so deleting it edits the
- *  claim rather than the prose. */
-const DELETIONS = [
-    'simply', 'seamlessly', 'effortlessly', 'blazingly', 'basically', 'essentially',
-    'it is worth noting that', 'it is important to note that', 'needless to say',
-]
-
-/** a real violation with no safe mechanical repair: the writer picks the fact */
-const VAGUE: Record<string, string> = {
-    robust: 'delete it, or give the measurable property',
-    powerful: 'delete it, or give the measurable property',
-    comprehensive: 'delete it, or name what it covers',
-    performant: 'delete it, or give the number',
-    'state-of-the-art': 'delete it',
-    'best-in-class': 'delete it',
-    ensure: 'write "make sure that", or name the guarantee',
-    etc: 'name the items, or write "and the rest of <the family>"',
-    'and/or': 'pick one, or write "X, or Y, or both"',
-    'as needed': 'state the condition',
-    'as necessary': 'state the condition',
-    'gracefully handles': 'say what it does',
-}
-
-const MODALS = ['should', 'would', 'may', 'might', 'could']
-
-const PARTICIPLES =
-    'written|built|done|made|kept|held|read|sent|shown|given|taken|known|seen|found|lost|run|set|put|told|left|drawn|thrown|caught|brought|bought|spent|meant|dealt|felt|gone|come|become|begun'
-
-// --- masking -------------------------------------------------------------
-
-const blankOut = (m: string): string => m.replace(/[^\n]/g, ' ')
-
-/** everything that is NOT house prose, blanked to spaces of the same length,
- *  so every offset a regex reports still points at the real source.
- *  Out of scope by the standard's own Untouchables plus the house exemptions:
- *  frontmatter, code fences, inline code, double-quoted verbatim spans,
- *  URLs and link targets, and `>` blockquotes (paste-ready copy). */
-export function maskProse(src: string): string {
-    let m = src.replace(/^---\n[\s\S]*?\n---\n/, blankOut)
-    m = m.replace(/```[\s\S]*?```/g, blankOut)
-    m = m.replace(/`[^`\n]*`/g, blankOut)
-    // a verbatim quote is spec, never house prose. The cap keeps one unpaired
-    // quote from swallowing the rest of the page.
-    m = m.replace(/"[^"]{0,800}"/g, blankOut)
-    m = m.replace(/“[^”]{0,800}”/g, blankOut)
-    // a verbatim quoted with SINGLE quotes, which house pages use as often as
-    // double ones. The opening quote must follow a boundary, so an apostrophe
-    // inside a word (`don't`) can never open a span and swallow the line.
-    // a word-internal apostrophe (`you're`) stays INSIDE the span. Real
-    // quotations are full of them, and a span that stops at the first one
-    // masks nothing, after which the fixer rewrites the quotation.
-    m = m.replace(/(^|[\s(\[])'(?:[^'\n]|(?<=\w)'(?=\w))*'(?=[\s.,;:!?)\]]|$)/gm, (full) => full[0] + blankOut(full.slice(1)))
-    m = m.replace(/(^|[\s(\[])‘[^’\n]{0,300}’/gm, (full) => full[0] + blankOut(full.slice(1)))
-    m = m.replace(/\]\([^)\n]*\)/g, blankOut)
-    m = m.replace(/https?:\/\/\S+/g, blankOut)
-    m = m.replace(/^[ \t]*>.*$/gm, blankOut)
-    return m
-}
-
-/** `is unmaintained` is a state, not a passive voice: there is no verb `to
- *  unmaintain`, so no actor exists to name. The `un-` prefix catches almost
- *  the whole family; the rest are participles coined off a noun. */
-const COINED = new Set(['gitignored', 'backticked', 'sandboxed', 'siloed'])
-/** words that end in the two letters and were never a verb. `be + \w+ed` cannot
- *  tell them from a participle, and it reported `is red` as a passive voice. */
-const NOT_PARTICIPLES = new Set(['red', 'tired', 'hundred', 'aged', 'learned', 'sacred', 'bed', 'need', 'feed', 'speed', 'seed', 'freed', 'agreed', 'indeed'])
-const isAdjectival = (participle: string): boolean => {
-    const w = participle.toLowerCase()
-    return (w.startsWith('un') && w.endsWith('ed')) || COINED.has(w) || NOT_PARTICIPLES.has(w)
-}
-
-/** a table row is structure: word classes still apply inside a cell, the
- *  sentence, paragraph and semicolon rules do not. A cell is not a sentence,
- *  so "write two sentences" asks for the table to be broken, and its items
- *  are already comma separated, which leaves the semicolon as the only
- *  separator the writer has left. */
-const isTableRow = (l: string): boolean => /^\s*\|/.test(l)
-
-/** a list item OPENS a new paragraph: a run of items with no blank line
- *  between them is a list, never a wall of text, and counting the run as one
- *  paragraph reported a five item list as 38 sentences. Both numbered forms,
- *  at any indentation. */
-const isListItem = (l: string): boolean => /^\s*(?:[-*+]|\d+[.)])\s/.test(l)
-
-const isStructureLine = (l: string): boolean => isTableRow(l) || /^\s*#{1,6}\s/.test(l) || /^\s*[-|: ]+$/.test(l)
-
-// --- sentence segmentation ----------------------------------------------
-
-/** house prose puts one bullet per line and uses ` — ` as a SEPARATOR, never
- *  as sentence punctuation (identity/writing-voice.md). Both are boundaries
- *  here, so a route line is not read as one 40-word sentence. */
-const splitSentences = (line: string): { text: string; at: number }[] => {
-    const out: { text: string; at: number }[] = []
-    let at = 0
-    for (const part of line.split(/(?<=[.!?])\s+|\s+[—–]\s+/)) {
-        const i = line.indexOf(part, at)
-        out.push({ text: part, at: i < 0 ? at : i })
-        at = (i < 0 ? at : i) + part.length
-    }
-    return out
-}
-
-/** STE counts a code span, a command or a path as ONE word */
-const wordCount = (s: string): number =>
-    s
-        .replace(/`[^`]*`/g, 'x')
-        .replace(/^\s*(?:[-*+]|\d+\.)\s+/, '')
-        .replace(/[*_]/g, '')
-        .split(/\s+/)
-        .filter((w) => /[A-Za-z0-9]/.test(w)).length
-
-// --- the checker ---------------------------------------------------------
-
-const capitalizeLike = (sample: string, replacement: string): string =>
-    /^[A-Z]/.test(sample) ? replacement.charAt(0).toUpperCase() + replacement.slice(1) : replacement
-
-const escapeRe = (s: string): string => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-
-/** one spelling for a word or phrase, so `Prior  To` and `prior to` are the
- *  same entry */
-export const normWord = (w: string): string => w.trim().toLowerCase().replace(/\s+/g, ' ')
-
-export function checkProse(src: string, opts: ProseOpts = {}): ProseHit[] {
-    const allow = new Set(opts.allow ?? [])
-    const allowWords = new Set((opts.words?.allow ?? []).map((a) => normWord(a.word)))
-    const masked = maskProse(src)
-    const hits: ProseHit[] = []
-    // line index → offset, once
-    const lineStart: number[] = [0]
-    for (let i = 0; i < src.length; i++) if (src[i] === '\n') lineStart.push(i + 1)
-    const lineOf = (off: number): number => {
-        let lo = 0
-        let hi = lineStart.length - 1
-        while (lo < hi) {
-            const mid = (lo + hi + 1) >> 1
-            if (lineStart[mid]! <= off) lo = mid
-            else hi = mid - 1
-        }
-        return lo + 1
-    }
-
-    const push = (cls: ProseClass, start: number, end: number, why: string, fix?: string, word?: string) => {
-        if (allow.has(cls)) return
-        const text = src.slice(start, end)
-        if (allowWords.size > 0 && (allowWords.has(normWord(text)) || (word != null && allowWords.has(word)))) return
-        hits.push({ line: lineOf(start), start, end, cls, tier: TIER[cls], text, fix, why, ...(word == null ? {} : { word }) })
-    }
-
-    /** the whole masked line an offset sits on, for the classes that need the
-     *  line's SHAPE (a table row, a list item) and not only the span */
-    const lineAt = (off: number): string => {
-        const from = masked.lastIndexOf('\n', off) + 1
-        const to = masked.indexOf('\n', off)
-        return masked.slice(from, to < 0 ? masked.length : to)
-    }
-
-    const scan = (re: RegExp, run: (m: RegExpExecArray) => void) => {
-        re.lastIndex = 0
-        let m: RegExpExecArray | null
-        while ((m = re.exec(masked)) != null) {
-            if (m[0].trim() === '') continue
-            run(m)
-        }
-    }
-
-    // --- fix tier
-    scan(new RegExp(`\\b(${Object.keys(CONTRACTIONS).map(escapeRe).join('|')})`, 'gi'), (m) => {
-        const full = CONTRACTIONS[m[0].toLowerCase()]
-        if (full != null) push('contraction', m.index, m.index + m[0].length, 'STE keeps the full form', capitalizeLike(m[0], full), m[0].toLowerCase())
-    })
-    scan(new RegExp(`(?<![\\w.])(${Object.keys(ABBREV).map(escapeRe).join('|')})`, 'gi'), (m) => {
-        const full = ABBREV[m[0].toLowerCase()]
-        if (full != null) push('abbrev', m.index, m.index + m[0].length, 'write the words a non-native reader can read', capitalizeLike(m[0], full), m[0].toLowerCase())
-    })
-    // a verb entry matches its inflected forms too, and the ending rides onto
-    // the replacement
-    const verbs = SUBSTITUTIONS.filter((x) => x.verb === true)
-    const plain = SUBSTITUTIONS.filter((x) => x.verb !== true)
-    for (const e of verbs) {
-        // a base ending in `e` drops it before `-ing` (leverage → leveraging),
-        // so the stem is matched both ways
-        const stem = e.from.endsWith('e') ? e.from.slice(0, -1) : e.from
-        scan(new RegExp(`\\b(?:${escapeRe(e.from)}(es|s|ed|d)?|${escapeRe(stem)}(ing))\\b`, 'gi'), (m) => {
-            const to = inflect(e.to, (m[1] ?? m[2] ?? '').toLowerCase())
-            push('slop', m.index, m.index + m[0].length, `STE writes '${e.to}'`, capitalizeLike(m[0], to), e.from)
-        })
-    }
-    scan(new RegExp(`\\b(${plain.map((x) => escapeRe(x.from)).join('|')})\\b`, 'gi'), (m) => {
-        const e = plain.find((x) => x.from === m[0]!.toLowerCase())
-        if (e != null) push('slop', m.index, m.index + m[0].length, `STE writes '${e.to}'`, capitalizeLike(m[0], e.to), e.from)
-    })
-    // a deletion gives back exactly one space, and WHICH one depends on what
-    // follows: before punctuation the space in front goes with the word, or
-    // the page keeps `the world : publish`. At the start of a line the fix is
-    // withheld entirely, because deleting the first word moves the capital
-    // onto the next one and that is the writer's call.
-    scan(new RegExp(`( *)\\b(${DELETIONS.map(escapeRe).join('|')})\\b( *)`, 'gi'), (m) => {
-        const lead = m[1] ?? ''
-        let end = m.index + m[0].length
-        const after = masked[end] ?? ''
-        const before = masked[m.index - 1] ?? ''
-        // inside an enumeration the word owns one of the two commas around it,
-        // or deleting it leaves `Also,, X`
-        if (before === ',' && after === ',') end += 1
-        const punctuationFollows = /[.,:;!?)\]]/.test(after)
-        const fix = lead === '' ? undefined : punctuationFollows ? '' : lead
-        push('slop', m.index, end, 'the word carries no fact', fix, normWord(m[2]!))
-    })
-    for (const p of PHRASE_SUBSTITUTIONS)
-        scan(new RegExp(p.re.source, 'gi'), (m) => push('slop', m.index, m.index + m[0].length, p.why, capitalizeLike(m[0], p.to), normWord(m[0].replace(/,\s*$/, ''))))
-
-    // --- hard tier
-    scan(new RegExp(`\\b(${MODALS.join('|')})\\b`, 'gi'), (m) =>
-        push('modal', m.index, m.index + m[0].length, "a requirement is 'must', a possibility is 'can', a recommendation is a fact or it is deleted", undefined, m[0].toLowerCase()),
-    )
-    scan(/;/g, (m) => {
-        if (isTableRow(lineAt(m.index))) return
-        push('semicolon', m.index, m.index + 1, 'write two sentences')
-    })
-    scan(/,\s+(\w+ing)\b/g, (m) => {
-        if (/^(nothing|something|anything|everything|during|string|thing)$/i.test(m[1]!)) return
-        // an `-ing` word used as an ADJECTIVE (`, missing path`) is not the
-        // participial clause the rule bans, and no regex can tell them apart.
-        // Measured on a real wiki, roughly two in three hits were a noun
-        // in an enumeration (`selection, loading, empty, error and the pager`)
-        // rather than a clause, which is why this class is SOFT: a rule that
-        // cries wolf gets switched off, and then it guards nothing.
-        if (/^(missing|following|existing|remaining|leading|trailing|incoming|outgoing|ongoing|pending|willing|living|growing|surrounding|underlying)$/i.test(m[1]!)) return
-        // `Renaming a file, moving a responsibility, or changing any contract`
-        // is a coordinated list of gerund NOUNS, not the participial clause
-        // the rule bans. The tell is a second gerund behind `and` or `or`.
-        if (/\b(and|or)\s+\w+ing\b/.test(lineAt(m.index))) return
-        push('comma-ing', m.index, m.index + m[0].length, "STE bans an '-ing' verb after a comma: start a new sentence, or write the relative clause")
-    })
-    scan(new RegExp(`\\b(has|have|had)\\s+(been|\\w+ed|${PARTICIPLES})\\b`, 'gi'), (m) =>
-        push('perfect', m.index, m.index + m[0].length, 'STE uses simple tenses only', undefined, normWord(m[0])),
-    )
-    scan(new RegExp(`\\b(${Object.keys(VAGUE).map(escapeRe).join('|')})\\b`, 'gi'), (m) => {
-        const why = VAGUE[m[0].toLowerCase()]
-        if (why != null) push('vague', m.index, m.index + m[0].length, why, undefined, m[0].toLowerCase())
-    })
-    // the repo's own ban list: hard, because the repo named the word itself.
-    // A house hit on the same span gives way, so one word reports once and
-    // with the repo's own replacement
-    const banned: [number, number][] = []
-    for (const b of opts.words?.ban ?? []) {
-        const w = normWord(b.word)
-        if (w === '') continue
-        const body = w.split(' ').map(escapeRe).join('\\s+')
-        scan(new RegExp(`(?<![\\w'-])${body}(?![\\w'-])`, 'gi'), (m) => {
-            if (allow.has('ban')) return
-            banned.push([m.index, m.index + m[0].length])
-            const why = `this repo refuses '${w}'${b.to != null && b.to !== '' ? `, write '${b.to}'` : ''}${b.reason != null && b.reason !== '' ? `: ${b.reason}` : ''}`
-            push('ban', m.index, m.index + m[0].length, why, b.to != null && b.to !== '' ? capitalizeLike(m[0], b.to) : undefined, w)
-        })
-    }
-
-    // --- soft tier, line by line
-    const limit = opts.strict === true ? 20 : 25
-    const lines = masked.split('\n')
-    let paraStart = -1
-    let paraSentences = 0
-    const flushParagraph = (endLine: number) => {
-        if (paraStart >= 0 && paraSentences > 6)
-            push('paragraph', lineStart[paraStart]!, lineStart[paraStart]! + (lines[paraStart]?.length ?? 0), `${paraSentences} sentences in one paragraph: STE allows six`)
-        paraStart = -1
-        paraSentences = 0
-        void endLine
-    }
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i]!
-        const off = lineStart[i]!
-        if (line.trim() === '') {
-            flushParagraph(i)
-            continue
-        }
-        if (isStructureLine(line)) {
-            flushParagraph(i)
-            continue
-        }
-        // passive voice: a form of `be` plus a past participle
-        const passRe = new RegExp(`\\b(is|are|was|were|be|been|being)\\s+(\\w+ed|${PARTICIPLES})\\b`, 'gi')
-        let pm: RegExpExecArray | null
-        while ((pm = passRe.exec(line)) != null) {
-            if (isAdjectival(pm[2]!)) continue
-            push('passive', off + pm.index, off + pm.index + pm[0].length, 'STE wants the active voice: name the actor', undefined, normWord(pm[0]))
-        }
-        const item = isListItem(line)
-        if (item) flushParagraph(i)
-        else if (paraStart < 0) paraStart = i
-        for (const s of splitSentences(line)) {
-            const w = wordCount(s.text)
-            if (!item && paraStart >= 0 && w > 0) paraSentences++
-            if (w > limit)
-                push('sentence', off + s.at, off + s.at + s.text.length, `${w} words: the limit is ${limit}`)
-        }
-    }
-    flushParagraph(lines.length)
-
-    if (banned.length > 0) {
-        const underBan = (h: ProseHit): boolean => h.cls !== 'ban' && h.word != null && banned.some(([a, b]) => h.start < b && a < h.end)
-        for (let i = hits.length - 1; i >= 0; i--) if (underBan(hits[i]!)) hits.splice(i, 1)
-    }
-    return hits.sort((a, b) => a.start - b.start)
-}
-
-/** apply every mechanical rewrite, left to right, first hit wins.
- *
- *  Two scans can claim the same characters: the deletion scan takes the space
- *  in front of its word, and a phrase substitution takes the space behind the
- *  comma it eats. Writing both over each other ate the text between them
- *  (`However, simply.` came back as `But `). So a hit that starts inside an
- *  already-applied span is DROPPED and the next pass picks it up on clean
- *  text, which is why this runs to a FIXED POINT rather than once. Bounded,
- *  because a fixer that cannot converge must say so rather than spin. */
-export function fixProse(src: string, opts: ProseOpts = {}): { text: string; applied: number } {
-    let text = src
-    let applied = 0
-    for (let pass = 0; pass < 5; pass++) {
-        const hits = checkProse(text, opts).filter((h) => h.fix != null)
-        if (hits.length === 0) break
-        let out = ''
-        let cursor = 0
-        let wrote = 0
-        for (const h of [...hits].sort((a, b) => a.start - b.start)) {
-            if (h.start < cursor) continue
-            out += text.slice(cursor, h.start) + h.fix
-            cursor = h.end
-            wrote++
-        }
-        if (wrote === 0) break
-        text = out + text.slice(cursor)
-        applied += wrote
-    }
-    return { text, applied }
-}
-
-/** what is wrong with a repo's word lists, judged the same way by the config
- *  loader and by the hub's writer: an empty word, a word listed twice, or a
- *  word both allowed and banned, which leaves the repo's intent undecidable */
-export function proseWordsProblems(w: ProseWords | undefined): string[] {
-    if (w == null) return []
-    if (typeof w !== 'object' || Array.isArray(w)) return ['prose.words is an object: { allow?: [...], ban?: [...] }']
-    const out: string[] = []
-    for (const k of Object.keys(w)) if (k !== 'allow' && k !== 'ban') out.push(`prose.words.${k} is not a key (keys: allow, ban)`)
-    const seen = new Map<string, 'allow' | 'ban'>()
-    for (const list of ['allow', 'ban'] as const) {
-        const entries: unknown = w[list] ?? []
-        if (!Array.isArray(entries)) {
-            out.push(`prose.words.${list} is a list`)
-            continue
-        }
-        for (const e of entries as { word?: unknown; to?: unknown; reason?: unknown }[]) {
-            if (e == null || typeof e.word !== 'string' || normWord(e.word) === '') {
-                out.push(`prose.words.${list} has an entry with no word`)
-                continue
-            }
-            const fields = list === 'ban' ? ['word', 'to', 'reason'] : ['word', 'reason']
-            for (const f of Object.keys(e)) if (!fields.includes(f)) out.push(`prose.words.${list} '${e.word}' has an unknown field '${f}' (fields: ${fields.join(', ')})`)
-            for (const f of ['to', 'reason'] as const) if (e[f] != null && typeof e[f] !== 'string') out.push(`prose.words.${list} '${e.word}' ${f} is a string`)
-            const n = normWord(e.word)
-            const was = seen.get(n)
-            if (was === list) out.push(`prose.words.${list} lists '${n}' twice`)
-            else if (was != null) out.push(`prose.words lists '${n}' in both allow and ban, pick one`)
-            seen.set(n, list)
-        }
-    }
-    return out
-}
-

package/src/scaffold/files/vscode-tasks.json

@@ -1,24 +0,0 @@
-{
-   // the hub is the one process every wired repo starts, so it opens with the
-   // folder itself. It runs every check after each save and its problem
-   // matcher fills the problems pane, so there is no type checker task. A
-   // stack that earns more long-running watchers (dev server, css) adds a
-   // master task with runOn folderOpen whose dependsOn lists them all, the hub
-   // included, and moves runOn off the hub.
-   "version": "2.0.0",
-   "tasks": [
-      {
-         "label": "🚀  shipkit",
-         "detail": "The shipkit hub at http://localhost:{{PORT}}, and every check's findings in the problems pane — clickable URLs: the page, /graph/wiki, /graph/agent",
-         "type": "process",
-         "command": "bun",
-         "args": ["run", "hub"],
-         "options": { "cwd": "${workspaceFolder}" },
-         "isBackground": true,
-         "presentation": { "reveal": "always", "close": false },
-         "group": { "kind": "build", "isDefault": true },
-         "runOptions": { "runOn": "folderOpen", "instanceLimit": 1 },
-         "problemMatcher": {{HUB_PROBLEM_MATCHER}}
-      }
-   ]
-}