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-ledger-schema.mjs

View on GitHub
// fact-ledger-schema.mjs - the fact ledger's vocabulary and validation: row fields and defaults,
// kinds, statuses, qualifiers, and validateLedger over rows, status events, and their history.
// The grammar it encodes is references/fact-ledger-grammar.md; every per-kind column rule lives in
// KIND_RULES (fact-ledger-kinds.mjs), never here.
// Pure functions with no IO; fact-ledger.mjs owns reading, writing, and row changes. node: builtins only.

import {
  DECIMAL,
  isCount,
  isCurrentDerived,
  isNonEmpty,
  isObject,
  isString,
  kindRuleErrors,
  LATER_COLUMNS,
  readRow,
  storedErrors,
} from "./fact-ledger-kinds.mjs"
import { malformed } from "./unit-rules.mjs"

export { DECIMAL, isNonEmpty, isString } from "./fact-ledger-kinds.mjs"

export const LEDGER_SCHEMA_VERSION = 1
export const FACT_KINDS = Object.freeze(["measured", "quote", "derived", "assumed", "converted"])
export const FACT_STATUSES = Object.freeze(["active", "superseded", "retracted"])
export const OPERATIONS = Object.freeze(["sum", "diff", "growth", "ratio", "share", "convert", "expr"])
/** Canonical qualifier terms; surface forms in either language map onto these. */
export const QUALIFIERS = Object.freeze([
  "upper_inclusive",
  "lower_inclusive",
  "approximate",
  "near",
  "lower_exclusive",
  "upper_exclusive",
])

export const ROW_DEFAULTS = Object.freeze({
  value: null,
  unit: null,
  value_span: null,
  source_id: null,
  locator: null,
  locate_hint: null,
  snapshot_sha256: null,
  valid_at: null,
  qualifier: null,
  entity: null,
  sentence_id: null,
  observation_id: null,
  fuzzy: false,
  outside_floor: false,
  population: null,
  missing_rule: null,
  accounting_basis: null,
  snapshot_window: null,
  revision: null,
  exact: null,
  render: null,
  operation: null,
  operands: [],
  derived_from: [],
  formula: null,
  factor: null,
  rationale: null,
  context: null,
  precision: null,
  compatibility: null,
  status: "active",
})
/** Fields added after schema version 1 shipped: written on every new row, optional when reading an older ledger. */
const OPTIONAL_FIELDS = new Set(LATER_COLUMNS)
const REQUIRED = ["fact_id", "kind", "raw", "quote", "extracted_by", "observed_at", "label"]
export const ROW_FIELDS = Object.freeze([...REQUIRED, ...Object.keys(ROW_DEFAULTS)])

const ISO_DATE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/
const LABEL = /^[a-z0-9_-]{1,32}$/
const FACT_REF = /^[FQ]\d+$/

function check(errors, condition, message) {
  if (!condition) errors.push(message)
}

function nullOr(value, test) {
  return value === null || test(value)
}

function validateRow(row, index, errors) {
  const at = `rows[${index}]`
  if (!isObject(row)) return errors.push(`${at} must be an object`)
  for (const key of ROW_FIELDS)
    check(errors, OPTIONAL_FIELDS.has(key) || Object.hasOwn(row, key), `${at}.${key} is required`)
  for (const key of Object.keys(row)) check(errors, ROW_FIELDS.includes(key), `${at}.${key} is not a ledger field`)
  check(errors, FACT_KINDS.includes(row.kind), `${at}.kind must be one of ${FACT_KINDS.join(", ")}`)
  // Dimension 31 wins at read time: per-kind rules see the row as readRow normalizes it.
  errors.push(...kindRuleErrors(readRow(row), at))
  errors.push(...storedErrors(row).map((e) => `${at}.${e}`))
  if (isCurrentDerived(row)) {
    const problem = malformed(row)
    if (problem) errors.push(`${at}: ${problem}`)
  }
  check(errors, row.unit === undefined || nullOr(row.unit, isNonEmpty), `${at}.unit must be null or a non-empty token`)
  for (const key of ["raw", "quote"])
    check(errors, row[key] === undefined || isString(row[key]), `${at}.${key} must be a string`)
  check(
    errors,
    row.extracted_by === undefined || isNonEmpty(row.extracted_by),
    `${at}.extracted_by must be a non-empty string`,
  )
  check(
    errors,
    row.observed_at === undefined || (isString(row.observed_at) && ISO_DATE.test(row.observed_at)),
    `${at}.observed_at must be an ISO timestamp`,
  )
  check(
    errors,
    row.label === undefined || (isString(row.label) && LABEL.test(row.label)),
    `${at}.label must match [a-z0-9_-]{1,32}`,
  )
  const span = row.value_span
  check(
    errors,
    span === undefined || nullOr(span, (v) => Array.isArray(v) && v.length === 2 && v.every(isCount) && v[0] <= v[1]),
    `${at}.value_span must be null or [start, end]`,
  )
  for (const key of [
    "locate_hint",
    "valid_at",
    "entity",
    "observation_id",
    "missing_rule",
    "accounting_basis",
    "formula",
    "render",
  ]) {
    if (row[key] !== undefined) check(errors, nullOr(row[key], isString), `${at}.${key} must be null or a string`)
  }
  for (const key of ["population", "snapshot_window", "revision"]) {
    if (row[key] !== undefined)
      check(
        errors,
        nullOr(row[key], (v) => isString(v) || isObject(v)),
        `${at}.${key} must be null, a string, or an object`,
      )
  }
  if (row.qualifier !== undefined)
    check(
      errors,
      nullOr(row.qualifier, (v) => QUALIFIERS.includes(v)),
      `${at}.qualifier must be null or one of ${QUALIFIERS.join(", ")}`,
    )
  if (row.sentence_id !== undefined)
    check(
      errors,
      nullOr(row.sentence_id, (v) => isString(v) && /^S\d+:s\d+$/.test(v)),
      `${at}.sentence_id must be null or S<n>:s<k>`,
    )
  for (const key of ["fuzzy", "outside_floor"]) {
    if (row[key] !== undefined) check(errors, typeof row[key] === "boolean", `${at}.${key} must be a boolean`)
  }
  if (row.operation !== undefined)
    check(
      errors,
      nullOr(row.operation, (v) => OPERATIONS.includes(v)),
      `${at}.operation must be null or one of ${OPERATIONS.join(", ")}`,
    )
  for (const key of ["operands", "derived_from"]) {
    if (row[key] !== undefined)
      check(
        errors,
        Array.isArray(row[key]) && row[key].every((v) => isString(v) && FACT_REF.test(v)),
        `${at}.${key} must be an array of fact ids`,
      )
  }
  if (row.factor !== undefined)
    check(
      errors,
      nullOr(row.factor, (v) => isString(v) && DECIMAL.test(v)),
      `${at}.factor must be null or a decimal string`,
    )
  check(
    errors,
    row.status === undefined || FACT_STATUSES.includes(row.status),
    `${at}.status must be one of ${FACT_STATUSES.join(", ")}`,
  )
}

export function rowErrors(row) {
  const errors = []
  validateRow(row, 0, errors)
  return errors
}

// The status machine and event rule of references/fact-ledger-grammar.md. validateLedger replays
// events through transitionError, and every writer in fact-ledger.mjs calls it before appending.
export const TRANSITIONS = Object.freeze({
  active: Object.freeze(["retracted", "superseded"]),
  retracted: Object.freeze([]),
  superseded: Object.freeze([]),
})
const EVENT_FIELDS = Object.freeze(["fact_id", "from", "to", "replacement", "reason"])

/**
 * @param {Map<string, string>} statuses each fact's status at the event's position
 * @returns {string | null} why the event is not a legal transition, or null
 */
export function transitionError(statuses, event) {
  if (!isObject(event)) return "an event must be an object"
  const id = event.fact_id
  if (!statuses.has(id)) return `no ledger row ${id}`
  if (
    EVENT_FIELDS.some((key) => !Object.hasOwn(event, key)) ||
    Object.keys(event).some((key) => !EVENT_FIELDS.includes(key))
  ) {
    return `${id}: an event has exactly the fields ${EVENT_FIELDS.join(", ")}`
  }
  const current = statuses.get(id)
  if (event.from !== current) return `${id} is ${current}, but the event moves it from ${event.from}`
  if (!TRANSITIONS[current].includes(event.to)) return `${id} cannot move from ${current} to ${event.to}`
  if (event.to === "superseded") {
    if (event.replacement === null)
      return `supersede ${id} needs a replacement row; use retract for a fact with no replacement`
    if (event.replacement === id) return `${id} cannot be its own replacement`
    if (!statuses.has(event.replacement)) return `no replacement row ${event.replacement} for ${id}`
    if (statuses.get(event.replacement) !== "active")
      return `replacement row ${event.replacement} is ${statuses.get(event.replacement)} (superseding ${id})`
  } else if (event.replacement !== null) return `${id} is ${event.to} but names replacement ${event.replacement}`
  if (!isNonEmpty(event.reason)) return `a reason is required to mark ${id} ${event.to}`
  return null
}

/** Replay every event from all-active; each row's status must be where its event chain leaves it. */
function validateHistory(ledger, errors) {
  const statuses = new Map(ledger.rows.filter(isObject).map((row) => [row.fact_id, "active"]))
  const counts = new Map()
  ledger.events.forEach((event, index) => {
    const problem = transitionError(statuses, event)
    if (problem) errors.push(`events[${index}]: ${problem}`)
    if (!isObject(event) || !statuses.has(event.fact_id) || !FACT_STATUSES.includes(event.to)) return
    statuses.set(event.fact_id, event.to)
    counts.set(event.fact_id, (counts.get(event.fact_id) ?? 0) + 1)
  })
  ledger.rows.forEach((row, index) => {
    if (!isObject(row) || !FACT_STATUSES.includes(row.status)) return
    const to = statuses.get(row.fact_id)
    if (!counts.has(row.fact_id))
      check(errors, row.status === "active", `rows[${index}]: ${row.fact_id} is ${row.status} but has no status event`)
    else
      check(
        errors,
        to === row.status,
        `rows[${index}]: ${row.fact_id} has status ${row.status} but its last event moves it to ${to}`,
      )
  })
}

/** operands and derived_from name existing rows, never the row itself, and close no cycle. */
export function provenanceErrors(rows) {
  const errors = []
  const refs = new Map()
  for (const row of rows)
    if (isObject(row))
      refs.set(
        row.fact_id,
        [row.operands, row.derived_from].flatMap((list) => (Array.isArray(list) ? list : [])),
      )
  rows.forEach((row, index) => {
    for (const key of ["operands", "derived_from"]) {
      if (!isObject(row) || !Array.isArray(row[key])) continue
      for (const ref of row[key]) {
        if (ref === row.fact_id) errors.push(`rows[${index}].${key}: ${ref} references itself`)
        else
          check(
            errors,
            refs.has(ref),
            `rows[${index}].${key}: ${row.fact_id} references ${ref}, which has no ledger row`,
          )
      }
    }
  })
  const state = new Map()
  for (const root of refs.keys()) {
    const stack = [{ id: root, finish: false }]
    const path = []
    while (stack.length) {
      const { id, finish } = stack.pop()
      if (state.get(id) === "done") continue
      if (finish) {
        state.set(id, "done")
        path.pop()
        continue
      }
      if (state.get(id) === "open")
        return [...errors, `${id} derives from itself through cycle ${[...path, id].join(" -> ")}`]
      state.set(id, "open")
      path.push(id)
      stack.push({ id, finish: true })
      for (const next of refs.get(id)) if (next !== id && refs.has(next)) stack.push({ id: next, finish: false })
    }
  }
  return errors
}

/** @returns {string[]} every schema error; empty when the ledger is valid. */
export function validateLedger(ledger) {
  const errors = []
  if (!isObject(ledger)) return ["ledger must be an object"]
  check(errors, ledger.schemaVersion === LEDGER_SCHEMA_VERSION, `schemaVersion must be ${LEDGER_SCHEMA_VERSION}`)
  if (!Array.isArray(ledger.rows)) return [...errors, "rows must be an array"]
  ledger.rows.forEach((row, index) => validateRow(row, index, errors))
  const ids = new Set()
  const labels = new Set()
  ledger.rows.forEach((row, index) => {
    if (!isObject(row)) return
    check(errors, !ids.has(row.fact_id), `rows[${index}].fact_id ${row.fact_id} is a duplicate`)
    check(
      errors,
      row.label === undefined || !labels.has(row.label),
      `rows[${index}]: ${row.fact_id} has duplicate label ${row.label}`,
    )
    ids.add(row.fact_id)
    labels.add(row.label)
  })
  errors.push(...provenanceErrors(ledger.rows))
  if (Array.isArray(ledger.events)) validateHistory(ledger, errors)
  else errors.push("events must be an array")
  return errors
}
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