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/fact-locate.mjs

View on GitHub
// fact-locate.mjs - deterministic fact locators over a source snapshot's locator text.
//
// Each locator returns { value, unit, raw, quote, value_span, sentence_id, qualifier, locator } or
// { error: "fact_not_located" | "fact_ambiguous", candidates }; it never guesses. `quote` is the
// whole containing sentence, cell, or line of the view text (source-view.mjs: the visible text
// nodes of a page, never markup), `value_span` is [start, end] inside `quote` with
// quote.slice(...value_span) === raw, and locator.char_start/char_end place `quote` in that text;
// raw-locator.mjs turns them into bytes. Every call takes `sourceId` (S<n>) so sentence ids match
// sentences.jsonl, which indexes the same text.
// Plain Node ESM, sibling imports only; no network, no OCR.

import { proseText } from "./html-lite.mjs"
import { QUALIFIERS } from "./lexicon.mjs"
import { parseNumeral } from "./numerals.mjs"
import { indexSentences, snapshotBlocks } from "./source-snapshot.mjs"
import { findNormalized, normalizeText, tokenize } from "./text-normalize.mjs"
import { similarity } from "./text-similarity.mjs"
import { normalizeUnit } from "./units.mjs"

const FIND_WINDOW = 80
const CONTEXT = 60
const FUZZY_FLOOR = 0.95
const PHRASES = QUALIFIERS.map((phrase) => phrase.split(" "))
const SINGLE_QUALIFIERS = new Set(QUALIFIERS.filter((phrase) => !phrase.includes(" ")))

const notLocated = (candidates = []) => ({ error: "fact_not_located", candidates })
const ambiguous = (candidates) => ({ error: "fact_ambiguous", candidates })
const label = (text) => normalizeText(text).toLowerCase()
const clean = (token) => token.replace(/^[^\p{L}\p{N}%]+|[^\p{L}\p{N}%]+$/gu, "").toLowerCase()
const sentenceAt = (sentences, offset) => sentences.find((row) => row.start <= offset && offset < row.end) ?? null

function requireSource(sourceId) {
  if (!/^S[1-9]\d*$/.test(String(sourceId))) throw new TypeError(`sourceId must be S<n>, got ${sourceId}`)
}

/** Every normalized occurrence of `needle`, as raw [start, end) offsets. */
function findAll(text, needle) {
  const hits = []
  for (let from = 0; from < text.length;) {
    const hit = findNormalized(text.slice(from), needle)
    if (!hit) break
    hits.push({ start: from + hit.start, end: from + hit.end })
    from += hit.start + 1
  }
  return hits
}

function locatorFor(text, sourceId, start, end, extra = {}) {
  const before = text.slice(0, start)
  const pageStart = before.lastIndexOf("\f") + 1
  const page = text.includes("\f") ? { page: before.split("\f").length } : {}
  return {
    artifact: `${sourceId}/text.txt`,
    ...page,
    line: before.slice(pageStart).split("\n").length,
    char_start: start,
    char_end: end,
    ...extra,
  }
}

function candidate(text, sentences, start, end) {
  return {
    sentence_id: sentenceAt(sentences, start)?.sid ?? null,
    char_start: start,
    char_end: end,
    context: text.slice(Math.max(0, start - CONTEXT), end + CONTEXT),
  }
}

/** A QUALIFIERS token ending within the 2 tokens before the value, or the 1 token right after it. */
function qualifierAround(quote, [start, end]) {
  const before = quote.slice(0, start).split(/\s+/).filter(Boolean).map(clean)
  for (let skip = 0; skip < 2; skip++) {
    for (const words of PHRASES) {
      const stop = before.length - skip
      if (stop - words.length >= 0 && before.slice(stop - words.length, stop).join(" ") === words.join(" "))
        return words.join(" ")
    }
  }
  const next = /^\s*(\S+)/.exec(quote.slice(end))
  return next && SINGLE_QUALIFIERS.has(clean(next[1])) ? clean(next[1]) : null
}

/** A located quantity: `holder` is the quote's { sid, start, end, text }, `numeral` is parsed from holder.text. */
function quantityResult(text, sourceId, holder, numeral, extra = {}, unitFallback = null) {
  const unit = numeral.unitRaw ? (normalizeUnit(numeral.unitRaw) ?? numeral.unitRaw) : unitFallback
  return {
    value: numeral.value,
    unit,
    raw: numeral.raw,
    quote: holder.text,
    value_span: [numeral.span[0], numeral.span[1]],
    sentence_id: holder.sid,
    qualifier: qualifierAround(holder.text, numeral.span),
    locator: locatorFor(text, sourceId, holder.start, holder.end, extra),
  }
}

/** --find: one anchor occurrence, then the first numeral starting within 80 chars after it in the same sentence. */
export function locateFind(text, { find, unitExpected, sourceId }) {
  requireSource(sourceId)
  const sentences = indexSentences(text, sourceId)
  const hits = findAll(text, find)
  if (hits.length === 0) return notLocated()
  if (hits.length > 1) return ambiguous(hits.map((hit) => candidate(text, sentences, hit.start, hit.end)))
  const [hit] = hits
  const sentence = sentenceAt(sentences, hit.start)
  if (!sentence || hit.end > sentence.end) return notLocated()
  const from = hit.end - sentence.start
  const numeral = parseNumeral(sentence.text, from)
  if (!numeral || numeral.span[0] - from > FIND_WINDOW)
    return notLocated([candidate(text, sentences, hit.start, hit.end)])
  const result = quantityResult(text, sourceId, sentence, numeral)
  if (unitExpected === undefined) return result
  const expected = normalizeUnit(unitExpected) ?? unitExpected
  return result.unit === expected
    ? result
    : { error: "unit_expected_mismatch", expected, found: result.unit, candidates: [result] }
}

/** A row's cells by visual column (a colspan cell repeats). */
export function cellsOf(row) {
  const cells = []
  for (const cell of row.children.filter((child) => child.tag === "td" || child.tag === "th")) {
    const span = Math.max(1, Number.parseInt(cell.attrs.colspan ?? "1", 10) || 1)
    for (let k = 0; k < span; k++) cells.push(cell)
  }
  return cells
}

export function rowsOf(table) {
  const rows = []
  const walk = (node) => {
    for (const child of node.children) {
      if (child.tag === "tr") rows.push(child)
      else if (child.tag !== "table" && child.tag !== "#text") walk(child)
    }
  }
  walk(table)
  return rows
}

function tablesOf(root) {
  const tables = []
  const walk = (node) => {
    for (const child of node.children) {
      if (child.tag === "table") tables.push(child)
      if (child.tag !== "#text") walk(child)
    }
  }
  walk(root)
  return tables.map((table) => {
    const rows = rowsOf(table)
    const header = rows.find((row) => row.children.some((child) => child.tag === "th")) ?? rows[0]
    const caption = table.children.find((child) => child.tag === "caption")
    return {
      table,
      header,
      rows: rows.filter((row) => row !== header),
      caption: caption ? label(proseText(caption)) : null,
    }
  })
}

const cellLabel = (cell) => label(proseText(cell))
const indexesOf = (labels, wanted) => labels.flatMap((value, index) => (value === wanted ? [index] : []))

/**
 * --table/--row/--col: the table by id, caption, or a header label; row and column by normalized label,
 * never by index. `source` is page html or an extracted view ({ root, text, blocks }) of one.
 */
export function locateTable(source, { table, row, col, sourceId }) {
  requireSource(sourceId)
  const { root, text, blocks } = typeof source === "string" ? snapshotBlocks(source) : source
  const key = label(table)
  const tables = tablesOf(root).filter(
    (entry) =>
      entry.table.attrs.id === table ||
      entry.caption === key ||
      (entry.header && cellsOf(entry.header).map(cellLabel).includes(key)),
  )
  if (tables.length !== 1)
    return tables.length === 0
      ? notLocated()
      : ambiguous(tables.map((entry) => ({ table: entry.table.attrs.id ?? entry.caption })))
  const [{ header, rows }] = tables
  const headerCells = header ? cellsOf(header) : []
  const columns = indexesOf(headerCells.map(cellLabel), label(col))
  const matches = rows.filter(
    (candidateRow) => cellsOf(candidateRow).length > 0 && cellLabel(cellsOf(candidateRow)[0]) === label(row),
  )
  if (columns.length > 1 || matches.length > 1)
    return ambiguous([
      ...columns.map((index) => ({ col: index })),
      ...matches.map((match) => ({ row_line: match.line })),
    ])
  const cell = columns.length === 1 && matches.length === 1 ? cellsOf(matches[0])[columns[0]] : null
  const block = cell ? blocks.find((entry) => entry.node === cell) : null
  if (!block) return notLocated()
  const holder = {
    sid: sentenceAt(indexSentences(text, sourceId), block.start)?.sid ?? null,
    start: block.start,
    end: block.end,
    text: text.slice(block.start, block.end),
  }
  const numeral = parseNumeral(holder.text)
  if (!numeral) return notLocated()
  const headerUnit = /\(([^()]+)\)\s*$/.exec(cellLabel(headerCells[columns[0]]))
  return quantityResult(
    text,
    sourceId,
    holder,
    numeral,
    { table, row_label: row, col_label: col },
    headerUnit ? normalizeUnit(headerUnit[1]) : null,
  )
}

/** --page/--line: exactly one quantity on that line of that page (pages split on a form feed). */
export function locatePageLine(text, { page, line, sourceId }) {
  requireSource(sourceId)
  const pages = text.split("\f")
  if (!Number.isInteger(page) || page < 1 || page > pages.length) return notLocated()
  const lines = pages[page - 1].split("\n")
  if (!Number.isInteger(line) || line < 1 || line > lines.length) return notLocated()
  let start = pages.slice(0, page - 1).reduce((sum, body) => sum + body.length + 1, 0)
  for (const body of lines.slice(0, line - 1)) start += body.length + 1
  const holder = { start, end: start + lines[line - 1].length, text: lines[line - 1] }
  const numerals = []
  for (let numeral = parseNumeral(holder.text); numeral; numeral = parseNumeral(holder.text, numeral.span[1]))
    numerals.push(numeral)
  const sentences = indexSentences(text, sourceId)
  if (numerals.length !== 1)
    return numerals.length === 0
      ? notLocated()
      : ambiguous(
          numerals.map((numeral) => candidate(text, sentences, start + numeral.span[0], start + numeral.span[1])),
        )
  holder.sid = sentenceAt(sentences, start + numerals[0].span[0])?.sid ?? null
  return quantityResult(text, sourceId, holder, numerals[0])
}

/** Token-aligned windows of `sentence` whose similarity to `match` reaches the fuzzy floor; best first. */
function fuzzyWindow(sentence, match) {
  const target = normalizeText(match).length
  const wanted = new Set(tokenize(match))
  const present = new Set(tokenize(sentence.text))
  if (wanted.size === 0 || [...wanted].filter((token) => present.has(token)).length / wanted.size < 0.5) return null
  const bounds = [...sentence.text.matchAll(/[\p{L}\p{N}]+/gu)].map((m) => [m.index, m.index + m[0].length])
  let best = null
  for (let i = 0; i < bounds.length; i++) {
    for (let j = i; j < bounds.length; j++) {
      const window = sentence.text.slice(bounds[i][0], bounds[j][1])
      if (window.length > target * 1.06 + 2) break
      if (window.length < target * 0.94 - 2) continue
      const score = similarity(window, match)
      if (score >= FUZZY_FLOOR && (!best || score > best.score))
        best = { score, start: sentence.start + bounds[i][0], end: sentence.start + bounds[j][1] }
    }
  }
  return best
}

function quoteResult(text, sourceId, sentences, start, end, fuzzy) {
  const first = sentenceAt(sentences, start)
  const last = sentenceAt(sentences, end - 1) ?? first
  return {
    value: null,
    unit: null,
    raw: text.slice(start, end),
    quote: text.slice(first.start, last.end),
    value_span: null,
    sentence_id: first.sid,
    qualifier: null,
    fuzzy,
    locator: locatorFor(text, sourceId, first.start, last.end),
  }
}

/** --match: a normalized exact match (fuzzy false), else the one window with similarity >= 0.95 (fuzzy true). */
export function locateMatch(text, { match, sourceId }) {
  requireSource(sourceId)
  const sentences = indexSentences(text, sourceId)
  const hits = findAll(text, match)
  if (hits.length > 1) return ambiguous(hits.map((hit) => candidate(text, sentences, hit.start, hit.end)))
  if (hits.length === 1) return quoteResult(text, sourceId, sentences, hits[0].start, hits[0].end, false)
  const windows = sentences.map((sentence) => fuzzyWindow(sentence, match)).filter(Boolean)
  if (windows.length > 1)
    return ambiguous(windows.map((window) => candidate(text, sentences, window.start, window.end)))
  return windows.length === 1
    ? quoteResult(text, sourceId, sentences, windows[0].start, windows[0].end, true)
    : notLocated()
}
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