Skip to content

code-yeongyu/oh-my-openagent / packages/shared-skills/skills/ulw-research

ulw-research

Unverified

Runs maximum-saturation research with a cooperating team, claim-graph gating, and a cited, QA'd deliverable. Use when the user explicitly asks for research or a deep investigation, including any 'ulw' research wording.

FileKindSize
AGENTS.mdmarkdown9.2 KB
ATTRIBUTION.mdmarkdown2.4 KB
SKILL.mdskill md42.2 KB
references/deliverable-phase.mdmarkdown49.1 KB
references/fact-ledger-grammar.mdmarkdown6.8 KB
references/fact-ledger.mdmarkdown24.4 KB
references/fidelity-claim-kinds.mdmarkdown5.2 KB
references/markdown-blocks.mdmarkdown721 B
references/report-gates.mdmarkdown32.0 KB
references/report-visualization.mdmarkdown15.4 KB
references/research-collection.mdmarkdown26.8 KB
references/research-delivery.mdmarkdown14.3 KB
references/unit-rules.mdmarkdown16.3 KB
scripts/claim-kinds.mjsscript11.2 KB
scripts/claim-kinds.test.tsscript13.5 KB
scripts/claim-prefix.test.tsscript4.9 KB
scripts/claims-index.mjsscript5.3 KB
scripts/claims-index.test.tsscript5.7 KB
scripts/cli-support.mjsscript4.1 KB
scripts/cli-support.test.tsscript4.3 KB
scripts/contracts-validation.test.tsscript3.3 KB
scripts/contracts.mjsscript26.1 KB
scripts/contracts.test.tsscript7.9 KB
scripts/conversion-altered.test.tsscript11.0 KB
scripts/conversion-originals.test.tsscript22.7 KB
scripts/conversion-probe-classes.test.tsscript45.2 KB
scripts/conversion-probe.mjsscript13.5 KB
scripts/conversion-probe.test.tsscript11.6 KB
scripts/copy-returns-fidelity-policy.test.tsscript10.4 KB
scripts/copy-returns-polish.test.tsscript12.1 KB
scripts/copy-returns.test.tsscript10.6 KB
scripts/css-hiding.mjsscript9.1 KB
scripts/css-lite.mjsscript7.6 KB
scripts/css-lite.test.tsscript6.4 KB
scripts/delivery-barrier-meaning.test.tsscript12.3 KB
scripts/delivery-barrier.test.tsscript11.4 KB
scripts/design-spec.mjsscript7.2 KB
scripts/design-spec.test.tsscript6.7 KB
scripts/entities.mjsscript2.5 KB
scripts/entry-guard.mjsscript794 B
scripts/fact-commands-fill.mjsscript6.6 KB
scripts/fact-commands-meaning.mjsscript12.6 KB
scripts/fact-commands-polish.mjsscript10.3 KB
scripts/fact-commands-verify.mjsscript12.6 KB
scripts/fact-commands.mjsscript13.8 KB
scripts/fact-derive-2.test.tsscript7.2 KB
scripts/fact-derive.mjsscript4.9 KB
scripts/fact-derive.test.tsscript10.8 KB
scripts/fact-expr.mjsscript4.5 KB
scripts/fact-fill.mjsscript11.7 KB
scripts/fact-fill.test.tsscript10.7 KB
scripts/fact-ledger-grammar.test.tsscript11.8 KB
scripts/fact-ledger-kinds.mjsscript16.5 KB
scripts/fact-ledger-kinds.test.tsscript9.3 KB
scripts/fact-ledger-legacy.test.tsscript8.9 KB
scripts/fact-ledger-schema.mjsscript11.9 KB
scripts/fact-ledger-schema.test.tsscript1.5 KB
scripts/fact-ledger.mjsscript5.5 KB
scripts/fact-ledger.test.tsscript9.7 KB
scripts/fact-locate.mjsscript12.1 KB
scripts/fact-locate.test.tsscript7.2 KB
scripts/fact-pairs.mjsscript8.3 KB
scripts/fact-pairs.test.tsscript6.6 KB
scripts/fact-recompute.mjsscript4.8 KB
scripts/fact-unit-dimensions-2.test.tsscript8.4 KB
scripts/fact-unit-dimensions.test.tsscript11.9 KB
scripts/fact-unit-rules.test.tsscript8.9 KB
scripts/fidelity-binding.mjsscript6.7 KB
scripts/fidelity-binding.test.tsscript4.0 KB
scripts/fidelity-brief.mjsscript6.4 KB
scripts/fidelity-brief.test.tsscript7.8 KB
scripts/fidelity-claims.mjsscript5.1 KB
scripts/fidelity-csv.mjsscript1.1 KB
scripts/fidelity-lexicon.mjsscript8.1 KB
scripts/fidelity-lexicon.test.tsscript6.0 KB
scripts/fidelity-originals.mjsscript9.9 KB
scripts/fidelity-policy.mjsscript10.1 KB
scripts/fidelity-records.mjsscript13.4 KB
scripts/fidelity-snapshot-readability.mjsscript2.2 KB
scripts/fidelity-sources.mjsscript4.3 KB
scripts/fidelity-state.mjsscript2.1 KB
scripts/fidelity-state.test.tsscript1.7 KB
scripts/fidelity-trace.mjsscript6.1 KB
scripts/fidelity-trace.test.tsscript3.3 KB
scripts/fidelity-value-unit.mjsscript13.3 KB
scripts/fidelity-values.mjsscript16.1 KB
scripts/fidelity-values.test.tsscript15.8 KB
scripts/format-extract-css.mjsscript5.1 KB
scripts/format-extract.mjsscript10.3 KB
scripts/format-extract.test.tsscript11.2 KB
scripts/gates-context.test.tsscript2.6 KB
scripts/gates-fidelity.mjsscript6.3 KB
scripts/gates-fidelity.test.tsscript3.3 KB
scripts/gates-figures.mjsscript9.9 KB
scripts/gates-layout.mjsscript6.6 KB
scripts/gates-layout.test.tsscript12.4 KB
scripts/gates-static-headings.test.tsscript961 B
scripts/gates-static.mjsscript8.1 KB
scripts/gates-static.test.tsscript14.9 KB
scripts/gates-structure.mjsscript4.7 KB
scripts/gates-text.mjsscript7.2 KB
scripts/glossary-vocabulary.test.tsscript1.7 KB
scripts/html-foreign-object.mjsscript2.8 KB
scripts/html-lite.mjsscript9.7 KB
scripts/html-lite.test.tsscript7.9 KB
scripts/html-markup.mjsscript7.0 KB
scripts/html-text-map.mjsscript4.8 KB
scripts/html-text-map.test.tsscript15.2 KB
scripts/layout-probe.mjsscript4.6 KB
scripts/layout-probe.test.tsscript4.2 KB
scripts/lexicon.mjsscript2.6 KB
scripts/lexicon.test.tsscript3.2 KB
scripts/markdown-closers.mjsscript4.9 KB
scripts/md-lite-boundaries.test.tsscript2.2 KB
scripts/md-lite.mjsscript7.8 KB
scripts/md-lite.test.tsscript10.3 KB
scripts/meaning-check.mjsscript9.7 KB
scripts/meaning-check.test.tsscript12.0 KB
scripts/number-grammar.mjsscript2.1 KB
scripts/number-grammar.test.tsscript1.8 KB
scripts/numerals.mjsscript12.0 KB
scripts/numerals.test.tsscript6.1 KB
scripts/outcome-start.mjsscript3.8 KB
scripts/outcome-start.test.tsscript5.0 KB
scripts/outcome.mjsscript10.5 KB
scripts/outcome.test.tsscript12.8 KB
scripts/page-source-locator.test.tsscript11.7 KB
scripts/particles-ko.mjsscript4.8 KB
scripts/particles-ko.test.tsscript4.3 KB
scripts/placeholder.mjsscript9.3 KB
scripts/placeholder.test.tsscript3.8 KB
scripts/polish-apply.mjsscript6.8 KB
scripts/polish-apply.test.tsscript19.7 KB
scripts/polish-diff.mjsscript1.7 KB
scripts/polish-diff.test.tsscript10.1 KB
scripts/polish-markup.test.tsscript14.0 KB
scripts/polish-partial.test.tsscript2.5 KB
scripts/polish-project.mjsscript5.8 KB
scripts/polish-rules.mjsscript9.8 KB
scripts/rational.mjsscript5.2 KB
scripts/rational.test.tsscript1.9 KB
scripts/raw-decode.mjsscript4.5 KB
scripts/raw-locator.mjsscript2.4 KB
scripts/raw-snapshot.test.tsscript7.3 KB
scripts/references-fences.test.tsscript1.2 KB
scripts/repair-tracker.mjsscript7.5 KB
scripts/repair-tracker.test.tsscript10.8 KB
scripts/report-tools-2.test.tsscript16.1 KB
scripts/report-tools-3.test.tsscript9.3 KB
scripts/report-tools-4.test.tsscript10.1 KB
scripts/report-tools-5.test.tsscript14.6 KB
scripts/report-tools-commands.mjsscript12.9 KB
scripts/report-tools.mjsscript2.6 KB
scripts/report-tools.test.tsscript12.1 KB
scripts/sentence-split.mjsscript3.0 KB
scripts/sentence-split.test.tsscript4.5 KB
scripts/snapshot-readability.test.tsscript7.0 KB
scripts/source-commands.mjsscript12.4 KB
scripts/source-integrity.test.tsscript18.1 KB
scripts/source-refresh.mjsscript5.2 KB
scripts/source-snapshot.mjsscript9.9 KB
scripts/source-snapshot.test.tsscript6.3 KB
scripts/source-view.mjsscript5.0 KB
scripts/sources-citation.mjsscript12.1 KB
scripts/sources-citation.test.tsscript14.8 KB
scripts/tests/contracts-support.tsscript3.5 KB
scripts/tests/delivery-barrier-session.tsscript3.3 KB
scripts/tests/derive-clock.tsscript341 B
scripts/tests/fact-derive-support.tsscript1.9 KB
scripts/tests/fact-unit-dimensions-support.tsscript1.5 KB
scripts/tests/fact-unit-rules-support.tsscript16.8 KB
scripts/tests/fidelity-values-support.tsscript1.6 KB
scripts/tests/fixtures/assets/figure-1.svgother141 B
scripts/tests/fixtures/bad-report.htmlother2.1 KB
scripts/tests/fixtures/boxes.jsonconfig3.2 KB
scripts/tests/fixtures/conversion-probe.htmlother485 B
scripts/tests/fixtures/design-spec.mdmarkdown458 B
scripts/tests/fixtures/fidelity-brief-locked.mdmarkdown571 B
scripts/tests/fixtures/fidelity-brief-pending.mdmarkdown574 B
scripts/tests/fixtures/fidelity/assets/share.csvother40 B
scripts/tests/fixtures/fidelity/claim-graph.mdmarkdown449 B
scripts/tests/fixtures/fidelity/gen-legacy-dev.mjsscript5.0 KB
scripts/tests/fixtures/fidelity/ledger-basic.jsonconfig5.1 KB
scripts/tests/fixtures/fidelity/ledger-legacy-dev.jsonconfig18.3 KB
scripts/tests/fixtures/fidelity/ledger-verify.jsonconfig9.1 KB
scripts/tests/fixtures/fidelity/polish-edits.jsonconfig303 B
scripts/tests/fixtures/fidelity/report-bad.htmlother821 B
scripts/tests/fixtures/fidelity/report-good.htmlother2.4 KB
scripts/tests/fixtures/fidelity/sources/S4.htmlother680 B
scripts/tests/fixtures/fidelity/sources/S4/acronyms.jsonconfig36 B
scripts/tests/fixtures/fidelity/sources/S4/meta.jsonconfig256 B
scripts/tests/fixtures/fidelity/sources/S4/sentences.jsonlother623 B
scripts/tests/fixtures/fidelity/sources/S4/text.txtmarkdown300 B
scripts/tests/fixtures/fidelity/sources/S5/acronyms.jsonconfig3 B
scripts/tests/fixtures/fidelity/sources/S5/meta.jsonconfig235 B
scripts/tests/fixtures/fidelity/sources/S5/sentences.jsonlother53 B
scripts/tests/fixtures/fidelity/sources/S5/text.txtmarkdown10 B
scripts/tests/fixtures/fidelity/sources/S9.txtmarkdown128 B
scripts/tests/fixtures/good-report.htmlother2.7 KB
scripts/tests/fixtures/reference-report.htmlother2.5 KB

scripts/gates-static.test.ts

View on GitHub
import { describe, expect, test } from "bun:test"
import { readFileSync } from "node:fs"
import { join } from "node:path"

import { DEFECT_CODES, STATIC_CODES } from "./contracts.mjs"
import { parseLineageMode, parsePalette } from "./design-spec.mjs"
import { checkStatic } from "./gates-static.mjs"
import { parseHtml } from "./html-lite.mjs"

type Defect = { code: string; severity: string; selector: string; line: number; message: string; hint: string }
type Result = { defects: Defect[]; gatesRun: string[]; gatesSkipped: string[] }
type FakeStat = { size: number }

const FIXTURES = join(import.meta.dir, "tests", "fixtures")
const GOOD = readFileSync(join(FIXTURES, "good-report.html"), "utf8")
const BAD = readFileSync(join(FIXTURES, "bad-report.html"), "utf8")
const SPEC = readFileSync(join(FIXTURES, "design-spec.md"), "utf8")
const PALETTE = parsePalette(SPEC)

function run(html: string, options: Record<string, unknown> = {}): Result {
  return checkStatic(parseHtml(html), {
    palette: PALETTE,
    lineageMode: parseLineageMode(SPEC),
    requireSections: [],
    baseDir: FIXTURES,
    ...options,
  }) as Result
}

const codes = (result: Result) => result.defects.map((defect) => defect.code)
const has = (html: string, code: string, options: Record<string, unknown> = {}) =>
  codes(run(html, options)).includes(code)

describe("checkStatic fixtures", () => {
  test("#given the passing fixture report #when every gate runs #then no defect is raised", () => {
    // given
    const options = { requireSections: [/sources/i, /review/i] }
    // when
    const result = run(GOOD, options)
    // then
    expect(codes(result)).toEqual([])
    expect(result.gatesSkipped).toEqual([])
    expect([...result.gatesRun].sort()).toEqual([...STATIC_CODES].sort())
  })

  test("#given the failing fixture report #when every gate runs #then each static code except the no-visual one is raised exactly once", () => {
    // given
    const options = { requireSections: [/risks/i] }
    // when
    const result = run(BAD, options)
    // then
    expect([...codes(result)].sort()).toEqual(STATIC_CODES.filter((code) => code !== "report_without_visual").sort())
    expect(STATIC_CODES).toHaveLength(19)
    expect(codes(result)).not.toContain("missing_promised_deliverable")
  })

  test("#given the failing fixture report #when defects are read #then each carries contract severity, selector, line, token message and hint", () => {
    // given
    const result = run(BAD, { requireSections: [/risks/i] })
    // when
    const byCode = new Map(result.defects.map((defect) => [defect.code, defect]))
    // then
    for (const defect of result.defects) {
      const contract = DEFECT_CODES[defect.code as keyof typeof DEFECT_CODES]
      expect(defect.severity).toBe(contract.severity)
      expect(defect.hint).toBe(contract.hint)
      expect(typeof defect.selector).toBe("string")
      expect(defect.selector.length).toBeGreaterThan(0)
      expect(Number.isInteger(defect.line)).toBe(true)
    }
    expect(byCode.get("palette_off_token")?.message).toContain("#123456")
    expect(byCode.get("unsourced_number")?.message).toContain("12.5%")
    expect(byCode.get("broken_asset_reference")?.message).toContain("missing-figure.png")
    expect(byCode.get("korean_serif_font")?.message).toContain("Nanum Myeongjo")
    expect(byCode.get("emoji_in_prose")?.message).toContain("\u{1F680}")
  })
})

describe("mutation proofs on the passing fixture", () => {
  test("#given keep-all removed #when checked #then only korean_no_keep_all is raised", () => {
    // given
    const mutated = GOOD.replace("word-break: keep-all;", "")
    // when
    const result = run(mutated, { requireSections: [/sources/i] })
    // then
    expect(codes(result)).toEqual(["korean_no_keep_all"])
  })

  test("#given the closing heading renamed #when checked #then the missing_closing_section blocker is raised", () => {
    // given
    const mutated = GOOD.replace("<h2>How this report was made</h2>", "<h2>Notes on the data</h2>")
    // when
    const result = run(mutated)
    // then
    const defect = result.defects.find((entry) => entry.code === "missing_closing_section")
    expect(defect?.severity).toBe("blocker")
  })

  test("#given the sources heading renamed #when checked #then the missing_citation_section blocker is raised", () => {
    // given
    const mutated = GOOD.replace("<h2>Sources</h2>", "<h2>Further reading</h2>")
    // when
    const result = run(mutated)
    // then
    const defect = result.defects.find((entry) => entry.code === "missing_citation_section")
    expect(defect?.severity).toBe("blocker")
  })

  test("#given no sources heading but three [S<n>] definition lines #when checked #then no citation-section blocker", () => {
    // given
    const html =
      "<h2>Notes</h2><p>[S1] First source title</p><p>[S2] Second source title</p><p>[Source 3] Third source title</p>"
    // when
    const found = has(html, "missing_citation_section")
    // then
    expect(found).toBe(false)
  })
})

describe("unsourced_number", () => {
  const claim = "\uB9E4\uCD9C\uC774 12.5% \uC99D\uAC00\uD588\uB2E4"

  test("#given a bare revenue claim #when checked #then unsourced_number is raised", () => {
    // given
    const html = `<p>${claim}</p>`
    // when
    const found = has(html, "unsourced_number")
    // then
    expect(found).toBe(true)
  })

  test.each([
    ["a [S3] marker", `<p>${claim} [S3]</p>`],
    ["a MEASURED token", `<p>${claim} MEASURED</p>`],
    ["a data-lineage attribute", `<p data-lineage="DERIVED">${claim}</p>`],
    ["a #s3 anchor", `<p>${claim} <a href="#s3">3</a></p>`],
  ])("#given the claim with %s #when checked #then it is not flagged", (_label, html) => {
    // given / when
    const found = has(html, "unsourced_number")
    // then
    expect(found).toBe(false)
  })

  test("#given dates, versions, figure refs and bare years only #when checked #then no claim is found", () => {
    // given
    const html = "<p>Released 2024-03-01 as v2.3.1 in 2019, see Figure 3 and Table 2.</p>"
    // when
    const found = has(html, "unsourced_number")
    // then
    expect(found).toBe(false)
  })

  test("#given inline and section lineage modes #when the same claim is checked #then severity is major then minor", () => {
    // given
    const html = `<p>${claim}</p>`
    // when
    const inline = run(html, { lineageMode: "inline" }).defects.find((d) => d.code === "unsourced_number")
    const section = run(html, { lineageMode: "section" }).defects.find((d) => d.code === "unsourced_number")
    // then
    expect(inline?.severity).toBe(DEFECT_CODES.unsourced_number.severity)
    expect(section?.severity).toBe("minor")
  })

  test("#given a claim inside a figure, a table and the closing section #when checked #then none is flagged", () => {
    // given
    const html = `<figure><p>${claim}</p><figcaption>x</figcaption></figure><table><tr><td><p>${claim}</p></td></tr></table><h2>How it was made</h2><p>${claim}</p>`
    // when
    const found = has(html, "unsourced_number")
    // then
    expect(found).toBe(false)
  })
})

describe("dashes and emoji", () => {
  test("#given an en dash between years #when checked #then it is allowed", () => {
    // given / when
    const found = has("<p>2019\u20132024</p>", "en_dash_in_prose")
    // then
    expect(found).toBe(false)
  })

  test("#given an en dash between letters #when checked #then en_dash_in_prose is raised", () => {
    // given / when
    const found = has("<p>a\u2013b</p>", "en_dash_in_prose")
    // then
    expect(found).toBe(true)
  })

  test("#given em dashes in a td and in the sources section #when checked #then they are out of prose scope", () => {
    // given
    const html = "<table><tr><td>\u2014</td></tr></table><h2>Sources</h2><ol><li>Title \u2014 subtitle</li></ol>"
    // when
    const found = has(html, "em_dash_in_prose")
    // then
    expect(found).toBe(false)
  })

  test("#given a check-mark emoji in prose #when checked #then emoji_in_prose is raised", () => {
    // given / when
    const found = has("<p>\u2705 done</p>", "emoji_in_prose")
    // then
    expect(found).toBe(true)
  })

  test("#given a plain check mark in a td #when checked #then no emoji is raised", () => {
    // given / when
    const found = has("<table><tr><td>\u2713</td></tr></table>", "emoji_in_prose")
    // then
    expect(found).toBe(false)
  })
})

describe("figures and charts", () => {
  test("#given a 16px svg inside an h2 #when checked #then it is not treated as a chart", () => {
    // given
    const html = '<h2>Title <svg width="16" height="16" viewBox="0 0 16 16"><path d="M0 0h16"/></svg></h2>'
    // when
    const found = codes(run(html)).filter((code) => code.startsWith("chart_"))
    // then
    expect(found).toEqual([])
  })

  test("#given a figure svg with title, three ticks and a label #when checked #then no chart defect", () => {
    // given
    const svg =
      '<svg width="400" height="200"><title>Deploys</title><text>0</text><text>5</text><text>10</text><text>Weeks</text></svg>'
    // when
    const found = codes(run(`<figure>${svg}<figcaption>Deploys per week</figcaption></figure>`)).filter((code) =>
      code.startsWith("chart_"),
    )
    // then
    expect(found).toEqual([])
  })
})

describe("report-level visuals", () => {
  const figures = /<figure\b[\s\S]*?<\/figure>/g

  test("#given the passing fixture with every figure removed #when checked #then only report_without_visual is raised", () => {
    // given
    const html = GOOD.replace(figures, "")
    // when
    const result = run(html, { requireSections: [/sources/i, /review/i] })
    // then
    expect(codes(result)).toEqual(["report_without_visual"])
    expect(result.defects[0]?.severity).toBe("major")
  })

  test("#given a header logo, an unrendered Mermaid source block, a zero-size svg, then a rendered diagram #when checked #then only the rendered diagram counts as a visual", () => {
    // given
    const logo =
      '<header><img src="data:image/png;base64,iVBORw0KGgo=" alt="logo" width="120" height="40"></header><p>x</p>'
    const unrendered = `${logo}<pre class="mermaid">flowchart LR\n  A --> B</pre><figure><svg width="0" height="0"><text>A</text></svg><figcaption>c</figcaption></figure>`
    const rendered = `${logo}<figure><svg width="600" height="300" aria-roledescription="flowchart-v2"><text>A</text><text>B</text></svg><figcaption>c</figcaption></figure>`
    // when / then
    expect(has(unrendered, "report_without_visual")).toBe(true)
    expect(has(rendered, "report_without_visual")).toBe(false)
  })

  test("#given rendered Mermaid diagrams with SVG text labels and with HTML-only labels #when checked #then only the HTML-only one is flagged and neither needs chart ticks", () => {
    // given
    const diagram = (labels: string) =>
      `<figure><svg width="600" height="300" aria-roledescription="flowchart-v2">${labels}</svg><figcaption>Gate order</figcaption></figure>`
    const textLabels = diagram("<text>static check</text><text>repair decide</text>")
    const htmlLabels = diagram("<foreignObject><div>static check</div></foreignObject>")
    // when
    const chartCodes = (html: string) => codes(run(html)).filter((code) => code.startsWith("chart_"))
    // then
    expect(chartCodes(textLabels)).toEqual([])
    expect(chartCodes(htmlLabels)).toEqual(["chart_svg_no_text"])
  })

  test("#given a single visual with one zero dimension #when checked #then report_without_visual is raised; viewBox-only and unsized visuals still count", () => {
    // given
    const only = (el: string) => `<figure>${el}<figcaption>c</figcaption></figure>`
    const flat = only('<img src="data:image/png;base64,iVBORw0KGgo=" alt="chart" width="600" height="0">')
    const narrow = only('<svg width="0" height="300"><text>A</text></svg>')
    const styled = only(
      '<img src="data:image/png;base64,iVBORw0KGgo=" alt="chart" width="600" height="300" style="height: 0">',
    )
    const viewBoxOnly = only('<svg viewBox="0 0 600 300" aria-roledescription="flowchart-v2"><text>A</text></svg>')
    const unsized = only('<img src="data:image/png;base64,iVBORw0KGgo=" alt="Deploys per week">')
    // when / then
    for (const html of [flat, narrow, styled]) expect(has(html, "report_without_visual")).toBe(true)
    for (const html of [viewBoxOnly, unsized]) expect(has(html, "report_without_visual")).toBe(false)
  })

  test("#given figure images with no alt, a bare empty alt, role- and aria-marked decorative alts and a descriptive alt #when checked #then only the unmarked two raise image_missing_alt", () => {
    // given
    const img = (alt: string) =>
      `<figure><img src="data:image/png;base64,iVBORw0KGgo=" ${alt} width="480" height="240"><figcaption>c</figcaption></figure>`
    const html = [
      "",
      'alt=""',
      'alt="" role="presentation"',
      'alt="" aria-hidden="true"',
      'alt="Deploys per week, 2025"',
    ]
      .map(img)
      .join("")
    // when
    const found = run(html).defects.filter((d) => d.code === "image_missing_alt")
    // then
    expect(found).toHaveLength(2)
  })

  test("#given a report whose only image is marked decorative #when checked #then report_without_visual is raised", () => {
    // given
    const html =
      '<figure><img src="data:image/png;base64,iVBORw0KGgo=" alt="" role="presentation" width="480" height="240"><figcaption>c</figcaption></figure>'
    // when / then
    expect(has(html, "report_without_visual")).toBe(true)
  })
})

describe("gate bookkeeping", () => {
  test("#given a spec with an empty palette #when checked #then palette_off_token is skipped, not run", () => {
    // given
    const palette = parsePalette("# Design spec\n\n## Citations\n- Lineage: inline\n")
    // when
    const result = run('<p style="color: #123456">x</p>', { palette })
    // then
    expect(palette.size).toBe(0)
    expect(result.gatesSkipped).toContain("palette_off_token")
    expect(result.gatesRun).not.toContain("palette_off_token")
    expect(codes(result)).not.toContain("palette_off_token")
  })

  test("#given an injected fs with a zero-byte and a missing asset #when checked #then both are broken and remote ones are ignored", () => {
    // given
    const sizes = new Map<string, number>([
      [join("base", "empty.png"), 0],
      [join("base", "ok.css"), 10],
    ])
    const fs = {
      statSync(file: string): FakeStat {
        const size = sizes.get(file)
        if (size === undefined) throw Object.assign(new Error("ENOENT"), { code: "ENOENT" })
        return { size }
      },
    }
    const html =
      '<link rel="stylesheet" href="ok.css"><img src="empty.png"><script src="gone.js"></script><img src="https://example.org/a.png">'
    // when
    const broken = run(html, { baseDir: "base", fs }).defects.filter((d) => d.code === "broken_asset_reference")
    // then
    expect(broken.map((d) => d.message.includes("empty.png") || d.message.includes("gone.js"))).toEqual([true, true])
  })

  test("#given an unknown lineage mode #when checked #then it throws instead of guessing a severity", () => {
    // given / when / then
    expect(() => run("<p>x</p>", { lineageMode: "loose" })).toThrow(TypeError)
  })
})
finishing-a-development-branchobra/superpowersUse when implementation is complete, all tests pass, and you need to decide how to integrate the workStars: 322kUpdated Claude CodeCodexVerifiedInstall
systematic-debuggingobra/superpowersUse when encountering any bug, test failure, or unexpected behavior, before proposing fixesStars: 322kUpdated Claude CodeCodexVerifiedInstall
test-driven-developmentobra/superpowersUse when implementing any feature or bugfix, before writing implementation codeStars: 322kUpdated Claude CodeCodexVerifiedInstall
skill-creatoranthropics/skillsCreate new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit, or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy.Stars: 198kUpdated Claude CodeCodexVerifiedInstall