code-yeongyu/oh-my-openagent / packages/shared-skills/skills/ulw-research
ulw-research
UnverifiedRuns 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.
scripts/polish-markup.test.ts
View on GitHubimport { describe, expect, test } from "bun:test"
import { markupParts, skeletonChange } from "./html-markup.mjs"
import { applyEdits, POLISH_MARKUP_REASON, POLISH_REFERENCE_REASON, textOf } from "./polish-apply.mjs"
import { diffPolish } from "./polish-diff.mjs"
const LEDGER = { rows: [{ fact_id: "F1", quote: "Revenue may reach 320 m." }] }
const FACT = '<data data-fact="F1">320 m</data>'
const BASE = `<p id="a" class="plain" style="color:red">Revenue may reach ${FACT} this year.</p>`
// The public polish boundary must freeze bytes, not inferred HTML/CSS semantics.
const MARKUP_CASES = [
["hidden added", BASE, BASE.replace("<p ", "<p hidden ")],
[
"id changed under existing CSS",
`<style>#gone{display:none}</style>${BASE}`,
`<style>#gone{display:none}</style>${BASE.replace('id="a"', 'id="gone"')}`,
],
["class changed", BASE, BASE.replace('class="plain"', 'class="gone"')],
["style changed", BASE, BASE.replace("color:red", "display:none")],
["stylesheet inserted", BASE, `<style>.plain{display:none}</style>${BASE}`],
["self-closing slash added", BASE, BASE.replace('color:red">', 'color:red"/>')],
["wrapper added", BASE, BASE.replace(FACT, `<span>${FACT}</span>`)],
["wrapper removed", BASE.replace(FACT, `<span>${FACT}</span>`), BASE],
["comment added", BASE, `${BASE}<!-- note -->`],
["comment changed", `${BASE}<!-- note -->`, `${BASE}<!-- notes -->`],
["attribute reorder", BASE, BASE.replace('id="a" class="plain"', 'class="plain" id="a"')],
["attribute quote changed", BASE, BASE.replace('id="a"', "id='a'")],
["attribute name case changed", BASE, BASE.replace('id="a"', 'ID="a"')],
["duplicate attribute changed", BASE.replace("<p ", '<p id="first" '), BASE.replace("<p ", '<p id="other" ')],
["href changed", '<a href="/a">Reference</a>', '<a href="/b">Reference</a>'],
["closing tag changed", BASE, BASE.replace("</p>", "</div>")],
["tag renamed", "<p>Results may improve.</p>", "<div>Results may improve.</div>"],
["tag whitespace changed", BASE, BASE.replace("<p ", "<p ")],
["declaration changed", `<!doctype html>${BASE}`, `<!DOCTYPE html>${BASE}`],
["script content changed", `${BASE}<script>let x = "note"</script>`, `${BASE}<script>let x = "notes"</script>`],
["style content changed", `${BASE}<style>.a{color:red}</style>`, `${BASE}<style>.a{color:tan}</style>`],
["template text changed", `${BASE}<template>note</template>`, `${BASE}<template>notes</template>`],
[
"nested template text changed",
`${BASE}<template><template>x</template>note</template>`,
`${BASE}<template><template>x</template>notes</template>`,
],
["unclosed script content changed", `${BASE}<script>note`, `${BASE}<script>notes`],
["unclosed template content changed", `${BASE}<template>note`, `${BASE}<template>notes`],
] as const
describe("polish text-node-only markup contract", () => {
test.each(MARKUP_CASES)(
"#given %s #then apply refuses markup changed and diff blocks",
(_label: string, before: string, after: string) => {
const result = applyEdits(before, [{ before, after }], LEDGER)
expect(result.applied).toEqual([])
expect(result.out).toBe(before)
expect(result.rejected[0]?.reason).toContain("markup changed")
const defects = diffPolish(before, after, LEDGER)
expect(defects.find((item: { code: string }) => item.code === "polish_diff_fail")?.severity).toBe("blocker")
},
)
test.each([
[
"existing self-closing hidden span",
`<p>Revenue ${FACT} may rise. <span hidden/> Fine.</p>`,
`<p>Revenue ${FACT} rise. <span hidden/> may Fine.</p>`,
],
[
"existing closed dialog",
`<p>Revenue ${FACT} may rise.</p><dialog>Note.</dialog>`,
`<p>Revenue ${FACT} rise.</p><dialog>may Note.</dialog>`,
],
[
"existing duplicate hidden style",
'<p>Results may improve.</p><div style="display:none" style="color:red">Note.</div>',
'<p>Results improve.</p><div style="display:none" style="color:red">may Note.</div>',
],
[
"aria-hidden fact text",
`<p>Revenue <span aria-hidden="true">${FACT}</span> may rise.</p>`,
`<p>Revenue <span aria-hidden="true">${FACT.replace("320", "321")}</span> may rise.</p>`,
],
[
"plain text inside aria-hidden fact",
'<q data-fact="F1" aria-hidden="true">Revenue may rise.</q>',
'<q data-fact="F1" aria-hidden="true">Revenue may soar.</q>',
],
[
"number moved between text nodes",
"<p>Revenue 320 m.</p><span hidden>Note.</span>",
"<p>Revenue.</p><span hidden>320 m Note.</span>",
],
])("#given %s #then protected text cannot migrate or change", (_label: string, before: string, after: string) => {
expect(applyEdits(before, [{ before, after }], LEDGER).applied).toEqual([])
expect(diffPolish(before, after, LEDGER).length).toBeGreaterThan(0)
})
test.each([
["plain prose", "<p>Results may improve steadily.</p>", "steadily", "slowly"],
["prose beside a fact", BASE, "this year", "next year"],
["quoted greater-than attribute", '<p title="a>b">Results may improve steadily.</p>', "steadily", "slowly"],
["literal less-than text", "<p>Growth < limits may persist steadily.</p>", "steadily", "slowly"],
["untouched entity beside the edit", "<p>R&D may grow steadily.</p>", "steadily", "slowly"],
[
"unchanged frozen content",
"<style>.a{display:none}</style><template>note</template><p>Results may improve steadily.</p>",
"steadily",
"slowly",
],
])(
"#given %s #then a text-only edit with protected tokens intact passes",
(_label: string, html: string, from: string, to: string) => {
const after = html.replace(from, to)
expect(applyEdits(html, [{ before: from, after: to }], LEDGER).out).toBe(after)
expect(diffPolish(html, after, LEDGER)).toEqual([])
},
)
})
// Review #11152 round 4: an edit may never carry <, > or &, so it cannot create, alter, close or
// escape any tag, comment, bogus comment, CDATA section, entity or script, whatever the tokenizer models.
const DATA = '<p>Revenue reached <data class="fact" data-fact="F1">320 m</data> in spring.</p>'
const SCRIPT = "<p>Results may improve steadily.</p><script><!--<script></script>foo();</script>"
describe("polish edits never carry markup characters", () => {
test.each([
["bogus comment before a fact span", DATA, "Revenue reached ", "Revenue reached </ "],
[
"bogus comment hiding a sentence",
"<p>Fine. The board met in spring.</p>",
"The board met in spring.",
"</ The board met in spring.>",
],
["empty end tag", "<p>Results may improve steadily.</p>", "steadily", "steadily </>"],
["introduced entity", "<p>Results may improve steadily.</p>", "steadily", "steadily <b>"],
["introduced greater-than", "<p>Results may improve steadily.</p>", "steadily", "steadily >"],
["removed entity", "<p>R&D may grow steadily.</p>", "R&D", "RD"],
])("#given %s #then apply rejects it and diff blocks", (_label: string, html: string, from: string, to: string) => {
const result = applyEdits(html, [{ before: from, after: to }], LEDGER)
expect(result.applied).toEqual([])
expect(result.out).toBe(html)
expect(result.rejected[0]?.reason).toContain(
"edit contains markup characters (<, >, &): route this section through the full fidelity gates",
)
if (from === "R&D" || to.includes("<") || to === "steadily >") return
expect(
diffPolish(html, html.replace(from, to), LEDGER).find(
(item: { code: string }) => item.code === "polish_diff_fail",
)?.severity,
).toBe("blocker")
})
test.each([
["words around R&D", "<p>Our R&D budget grew in 2025.</p>", "budget grew", "budget rose", true],
[
"an edit spanning R&D",
"<p>Our R&D budget grew in 2025.</p>",
"Our R&D budget grew",
"The R&D budget rose",
false,
],
[
"words around p < 0.05",
"<p>The effect held at p < 0.05 in the trial.</p>",
"in the trial",
"across the trial",
true,
],
[
"an edit spanning p < 0.05",
"<p>The effect held at p < 0.05 in the trial.</p>",
"held at p < 0.05",
"stayed at p < 0.05",
false,
],
])(
"#given legitimate prose with %s #then only an edit leaving the entity bytes untouched applies",
(_label: string, html: string, from: string, to: string, passes: boolean) => {
const result = applyEdits(html, [{ before: from, after: to }], LEDGER)
if (passes) {
expect(result.out).toBe(html.replace(from, to))
expect(diffPolish(html, result.out, LEDGER)).toEqual([])
return
}
expect(result.out).toBe(html)
expect(result.rejected[0]?.reason).toContain(POLISH_MARKUP_REASON)
},
)
test("#given double-escaped script code #then the ambiguity refusal blocks a text-only edit of it", () => {
const result = applyEdits(SCRIPT, [{ before: "foo();", after: "bar();" }], LEDGER)
expect(result.applied).toEqual([])
expect(result.rejected[0]?.reason).toContain("ambiguous markup: <!-- inside script")
expect(diffPolish(SCRIPT, SCRIPT.replace("foo", "bar"), LEDGER)[0]?.message).toContain("ambiguous markup")
})
test.each([
["end tag open before a non-letter", "<p>a </ b> c</p>"],
["empty end tag", "<p>a </> c</p>"],
["comment opener inside script", "<script><!-- x --></script><p>c</p>"],
["comment opener inside style", "<style><!-- .a{} --></style><p>c</p>"],
["CDATA section", "<p>a <![CDATA[ b ]]> c</p>"],
["processing instruction", "<p>a <?x b?> c</p>"],
["less-than inside an attribute value", '<p title="a<b">c</p>'],
["comment closed by --!>", "<p>a <!-- b --!> c</p>"],
])("#given a document with %s #then diff refuses it as ambiguous markup", (_label: string, html: string) => {
const defect = diffPolish(html, html, LEDGER).find((item: { code: string }) => item.code === "polish_diff_fail")
expect(defect?.message).toContain("ambiguous markup")
})
test("#given an end tag open before a non-letter #then the tokenizer skips a bogus comment to the next >", () => {
expect(markupParts("a </ b> c </> d").markup).toEqual(["</ b>", "</>"])
})
test("#given a double-escaped script #then the script runs to the close outside the escape", () => {
expect(markupParts(`${SCRIPT}<p>x</p>`).markup).toEqual([
"<p>",
"</p>",
"<script><!--<script></script>foo();</script>",
"<p>",
"</p>",
])
expect(markupParts("<script><!-- a --></script><b>x</b>").markup).toEqual([
"<script><!-- a --></script>",
"<b>",
"</b>",
])
})
})
// Review #11152 round 5: the primary rule is a whole-document skeleton comparison. Every markup
// token and every character reference in text must be byte-identical; an edit's located region may
// not touch a character reference either, so an edit can neither change nor create one.
const AMPD = "<p>We fund R&D labs here.</p>"
const TOM = "<p>Tom & Jerry ran.</p>"
describe("polish keeps character references intact", () => {
test.each(["style", "p"])(
"#given a quoted greater-than in a %s end tag #when its quote changes #then diff blocks",
(tag: string) => {
const before = `<${tag}>p{}</${tag} a='>'> trailing prose`
const after = before.replace(">'", ">x")
expect(diffPolish(before, after, LEDGER).map((item: { code: string }) => item.code)).toContain("polish_diff_fail")
},
)
test.each(["&.", `&${"a".repeat(24)}.`])(
"#given %s immediately before an edit #when extended #then the reference reason is actionable",
(reference: string) => {
const html = `<p>${reference} next</p>`
const result = applyEdits(html, [{ before: " next", after: "later" }], LEDGER)
expect(result.rejected[0]?.reason).toContain(POLISH_REFERENCE_REASON)
expect(result.out).toBe(html)
expect(
diffPolish(html, html.replace(" next", "later"), LEDGER).map((item: { code: string }) => item.code),
).toContain("polish_diff_fail")
},
)
test.each([
["an edit starting inside an entity", AMPD, "amp;D labs", "lt;D labs"],
["an edit starting right after a bare ampersand", TOM, " Jerry ran", "lt; ran"],
])(
"#given %s #then apply refuses it and diff blocks the hand edit",
(_label: string, html: string, from: string, to: string) => {
const result = applyEdits(html, [{ before: from, after: to }], LEDGER)
expect(result.applied).toEqual([])
expect(result.out).toBe(html)
expect(result.rejected[0]?.reason).toContain("character reference")
const defects = diffPolish(html, html.replace(from, to), LEDGER)
expect(defects.find((item: { code: string }) => item.code === "polish_diff_fail")?.severity).toBe("blocker")
},
)
test("#given a hand edit from R&D to R<D #then diff blocks it", () => {
const defect = diffPolish(AMPD, AMPD.replace("&", "<"), LEDGER).find(
(item: { code: string }) => item.code === "polish_diff_fail",
)
expect(defect?.message).toContain("skeleton changed")
})
test.each([
["an entity changed", AMPD, AMPD.replace("&", "<")],
["an entity created", TOM, "<p>Tom < ran.</p>"],
["an entity removed", AMPD, AMPD.replace("R&D", "RD")],
["a tag changed", AMPD, AMPD.replace("<p>", "<div>")],
])(
"#given %s #then the skeleton check alone names the first differing token",
(_label: string, before: string, after: string) => {
expect(skeletonChange(before, after)).toContain("skeleton changed at token")
},
)
test.each([
["words beside an entity", AMPD, AMPD.replace("labs here", "labs nearby")],
["words beside a bare ampersand", TOM, TOM.replace("ran", "walked")],
["an unchanged document", AMPD, AMPD],
])("#given %s #then the skeleton is unchanged", (_label: string, before: string, after: string) => {
expect(skeletonChange(before, after)).toBeNull()
})
test("#given a quoted greater-than in an attribute #then the text projection follows the scanner", () => {
expect(textOf('<p title="a>b">Results may improve.</p>').trim()).toBe("Results may improve.")
})
})
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| finishing-a-development-branchobra/superpowersUse when implementation is complete, all tests pass, and you need to decide how to integrate the work | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| systematic-debuggingobra/superpowersUse when encountering any bug, test failure, or unexpected behavior, before proposing fixes | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| test-driven-developmentobra/superpowersUse when implementing any feature or bugfix, before writing implementation code | Stars: 322k | Updated | Claude CodeCodex | Verified | Install |
| 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: 198k | Updated | Claude CodeCodex | Verified | Install |