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-commands-meaning.mjs

View on GitHub
// fact-commands-meaning.mjs - `fact pairs` and `fact meaning-check`, the script half of the
// separate-session meaning verifier. fact pairs writes the (source, report sentence) pairs a
// reader lane gets and nothing else (with --changed-since, only the pairs whose sentence changed
// since the pre-polish fill map's artifact, or all when those bytes are gone); it honours the brief's `meaning check` field and writes
// `{ skipped: true }` when it is off. fact meaning-check ingests the readers' verdict files
// (meaning-check.mjs), writes the meaning record of one edition (fidelity-meaning-defects.<format>.json
// with --edition, else the legacy fidelity-meaning-defects.json; a fidelity record bound to the pairs'
// artifact_sha256 and report, through writeFidelityRecord), and records the run in
// fidelity-calibration.jsonl: a header with the promotion criterion on first write, then per run
// one run line plus one line per flagged pair. The run id hashes the inputs only, so a rerun or a
// --dispute rerun of the same inputs replaces that run's lines in place (disputes carry forward)
// instead of counting a second run. Both refuse an unlocked brief (fidelity_interview_incomplete) before
// reading anything else. Neither command calls a model or the network.

import { existsSync, readFileSync } from "node:fs"
import { dirname, join, resolve } from "node:path"

import { CliError, parseArgs, readJsonFile, sha256Of, writeJsonAtomic, writeTextAtomic } from "./cli-support.mjs"
import { countDefects, DELIVERABLE_FORMATS } from "./contracts.mjs"
import { ledgerFrom, markdownAsHtml, readEdition, sessionOf } from "./fact-commands-verify.mjs"
import { pairsChangedSince } from "./fact-commands-polish.mjs"
import { extractPairs, PAIR_KINDS } from "./fact-pairs.mjs"
import { FIDELITY_INCOMPLETE } from "./fidelity-brief.mjs"
import { briefPathOf, lockedBrief, meaningCheckEnabled } from "./fidelity-policy.mjs"
import { MEANING_RECORD, meaningRecordName, writeFidelityRecord } from "./fidelity-records.mjs"
import { blocksDelivery } from "./gates-fidelity.mjs"
import { ingestVerdicts, unverifiedDefects, VERDICT_SCHEMA } from "./meaning-check.mjs"

export const PAIRS_FILE = "pairs.json"
export const CALIBRATION_FILE = "fidelity-calibration.jsonl"
/** Starting values, recorded in the calibration log header; changed only with evidence. */
export const PROMOTION = Object.freeze({
  code: "meaning_drift_confirmed",
  to: "integrity",
  min_runs: 20,
  max_disputed_to_confirmed: 0.1,
  false_block_window: 20,
  max_report_false_blocks_in_window: 2,
})

/** The command status: fail when any defect blocks delivery under the registry policy. */
export const meaningStatus = (defects) => (defects.some(blocksDelivery) ? "fail" : "pass")

const inSession = (session, name, flag) => {
  if (session === null) throw new CliError(`${flag} is required without --session-dir (or SESSION_DIR)`)
  return join(session, name)
}

function runPairs(args) {
  const [report] = args.positionals
  const { flags } = args
  if (!report)
    throw new CliError(
      "usage: fact pairs <report> [--format html|md] [--ledger F] [--claims claims.json] [--changed-since <fill-map.json>] [--brief brief.md] [--out pairs.json]",
    )
  const session = sessionOf(flags)
  const out = resolve(flags.out ?? inSession(session, PAIRS_FILE, "--out"))
  const { parsed, refusal } = lockedBrief("fact pairs", flags)
  if (refusal) return refusal
  if (!meaningCheckEnabled(parsed)) {
    const record = { schemaVersion: 1, skipped: true, reason: "meaning check: off", pairs: [] }
    writeJsonAtomic(out, record)
    return {
      json: { command: "fact pairs", status: "skipped", exitCode: 0, data: { out, ...record } },
      summary: "fact pairs: skipped (meaning check: off)",
      exitCode: 0,
    }
  }
  const edition = readEdition(report, flags)
  const claimsPath = flags.claims ?? (session === null ? null : join(session, "claims.json"))
  const claims =
    claimsPath !== null && (flags.claims !== undefined || existsSync(claimsPath)) ? readJsonFile(claimsPath) : null
  const ledger = ledgerFrom(flags, session)
  const html = edition.format === "md" ? markdownAsHtml(edition.text, edition.entries, ledger).html : edition.text
  const all = extractPairs(html, ledger, claims)
  const since =
    flags["changed-since"] === undefined ? null : pairsChangedSince(all, flags["changed-since"], ledger, claims)
  const pairs = since?.pairs ?? all
  const counts = { total: pairs.length, force_strong: pairs.filter((pair) => pair.force_strong).length }
  for (const kind of PAIR_KINDS) counts[kind] = pairs.filter((pair) => pair.kind === kind).length
  const changed = since === null ? {} : { changed_since: { fill_map: since.fill_map, narrowed: since.narrowed } }
  const record = {
    schemaVersion: 1,
    skipped: false,
    report: resolve(report),
    format: edition.format,
    artifact_sha256: sha256Of(edition.text),
    pairs_sha256: sha256Of(JSON.stringify(pairs)),
    counts,
    ...changed,
    verdict_schema: VERDICT_SCHEMA,
    pairs,
  }
  writeJsonAtomic(out, record)
  const summary = `fact pairs: ${counts.total} pair(s), ${counts.force_strong} routed to the strong reader`
  return {
    json: { command: "fact pairs", status: "pass", exitCode: 0, data: { out, ...record, pairs: undefined } },
    summary,
    exitCode: 0,
  }
}

/** Every line of the log after the header, in file order; a corrupt line is a usage error naming path:line. */
function calibrationRows(path) {
  if (!existsSync(path)) return []
  const rows = []
  for (const [index, line] of readFileSync(path, "utf8").split("\n").entries()) {
    if (line.trim() === "") continue
    try {
      rows.push(JSON.parse(line))
    } catch (error) {
      throw new CliError(
        `${path}:${index + 1}: corrupt calibration log line (${error.message}); repair or move the file`,
      )
    }
  }
  return rows.filter((row) => row.header !== true)
}

/** The promotion criterion evaluated over the log: runs, disputed-to-confirmed, report-level false blocks. */
export function promotionEligibility(rows) {
  const runs = [...new Set(rows.map((row) => row.run_id))]
  const confirmed = rows.filter((row) => row.run !== true && row.confirmed)
  const disputed = confirmed.filter((row) => row.disputed).length
  const ratio = confirmed.length === 0 ? null : disputed / confirmed.length
  const falseBlocks = runs.slice(-PROMOTION.false_block_window).filter((run) => {
    const blocking = confirmed.filter((row) => row.run_id === run)
    return blocking.length > 0 && blocking.every((row) => row.disputed)
  }).length
  const eligible =
    runs.length >= PROMOTION.min_runs &&
    ratio !== null &&
    ratio < PROMOTION.max_disputed_to_confirmed &&
    falseBlocks <= PROMOTION.max_report_false_blocks_in_window
  return {
    runs: runs.length,
    confirmed: confirmed.length,
    disputed_confirmed: disputed,
    disputed_to_confirmed: ratio,
    report_false_blocks_in_window: falseBlocks,
    eligible,
  }
}

/**
 * Writes this run's lines: one run line (so a run with no flagged pair still counts) and one line per
 * flagged pair. A run id already in the log is replaced in place, keeping its position in the false
 * block window and any earlier dispute on a pair the new lines do not dispute.
 */
function recordCalibration(path, lines, runId, pairsSha) {
  const before = calibrationRows(path)
  const previous = before.filter((row) => row.run_id === runId)
  const disputes = new Map(previous.filter((row) => row.disputed).map((row) => [row.pair_id, row.reason]))
  const pairRows = lines.map((line) => {
    const row = { ...JSON.parse(line), run_id: runId, pairs_sha256: pairsSha }
    return !row.disputed && disputes.has(row.pair_id)
      ? { ...row, disputed: true, reason: disputes.get(row.pair_id) }
      : row
  })
  const rows = [{ run: true, run_id: runId, pairs_sha256: pairsSha, flagged: pairRows.length }, ...pairRows]
  const at = previous.length === 0 ? before.length : before.indexOf(previous[0])
  const after = [
    ...before.slice(0, at).filter((row) => row.run_id !== runId),
    ...rows,
    ...before.slice(at).filter((row) => row.run_id !== runId),
  ]
  const header = {
    header: true,
    schemaVersion: 1,
    promotion: PROMOTION,
    note: "starting values; change them only with evidence",
  }
  writeTextAtomic(path, `${[header, ...after].map((row) => JSON.stringify(row)).join("\n")}\n`)
  return { written: pairRows.length, replaced: previous.length > 0, rows: after }
}

/** A `{ skipped: true }` pairs file is accepted only when the locked brief turns the meaning check off. */
function skippedRefusal(flags, parsed) {
  if (meaningCheckEnabled(parsed))
    return {
      error: "meaning_check_required",
      message: `${flags.pairs} says skipped but ${briefPathOf(flags)} has meaning check on; rerun fact pairs`,
    }
  return null
}

function runMeaningCheck(args) {
  const { flags } = args
  const usage =
    "usage: fact meaning-check --pairs pairs.json --verdicts cheap.json [--verdicts strong.json] [--dispute P<n> --reason TEXT] [--run-id ID] [--calibration F] [--brief brief.md] [--edition FORMAT] [--out F]"
  if (flags.pairs === undefined || !Array.isArray(flags.verdicts)) throw new CliError(usage)
  if (flags.edition !== undefined && !DELIVERABLE_FORMATS.includes(flags.edition))
    throw new CliError(
      `--edition must be a deliverable format (${DELIVERABLE_FORMATS.join(", ")}), got ${flags.edition}`,
    )
  const session = sessionOf(flags)
  const { parsed, refusal } = lockedBrief("fact meaning-check", flags)
  if (refusal) return { ...refusal, json: { ...refusal.json, error: FIDELITY_INCOMPLETE } }
  const pairsText = readFileSync(flags.pairs, "utf8")
  const pairsDoc = readJsonFile(flags.pairs)
  if (pairsDoc?.skipped === true) {
    const skipped = skippedRefusal(flags, parsed)
    if (skipped !== null)
      return {
        json: { command: "fact meaning-check", status: "fail", exitCode: 1, ...skipped },
        summary: `fact meaning-check: ${skipped.message}`,
        exitCode: 1,
      }
    return {
      json: { command: "fact meaning-check", status: "skipped", exitCode: 0, defects: [] },
      summary: JSON.stringify({ command: "fact meaning-check", status: "skipped" }),
      exitCode: 0,
    }
  }
  if (typeof pairsDoc?.artifact_sha256 !== "string" || typeof pairsDoc.report !== "string")
    throw new CliError(
      `${flags.pairs} names no artifact_sha256 and report, so the meaning record cannot be bound to an edition; rerun fact pairs`,
    )
  for (const file of flags.verdicts) readJsonFile(file)
  const verdictTexts = flags.verdicts.map((file) => readFileSync(file, "utf8"))
  const dispute = flags.dispute === undefined ? undefined : { pair_id: flags.dispute, reason: args.required("reason") }
  let result
  try {
    result = ingestVerdicts(pairsDoc, flags.verdicts, dispute ? { dispute } : {})
  } catch (error) {
    throw new CliError(`invalid verdict input: ${error.message}`)
  }
  const out = resolve(
    flags.out ??
      inSession(session, flags.edition === undefined ? MEANING_RECORD : meaningRecordName(flags.edition), "--out"),
  )
  const calibration = resolve(flags.calibration ?? join(session ?? dirname(out), CALIBRATION_FILE))
  const runId = flags["run-id"] ?? sha256Of([pairsText, ...verdictTexts].join("\0")).slice(0, 16)
  const pairsSha = pairsDoc.pairs_sha256 ?? sha256Of(pairsText)
  const log = recordCalibration(calibration, result.calibrationLines, runId, pairsSha)
  const defects = [...result.defects, ...unverifiedDefects(result.unverified)]
  const counts = countDefects(defects)
  const status = meaningStatus(defects)
  const exitCode = status === "fail" ? 1 : 0
  const record = writeFidelityRecord(out, "meaning", {
    command: "fact meaning-check",
    status,
    exitCode,
    artifact_sha256: pairsDoc.artifact_sha256,
    report: pairsDoc.report,
    run_id: runId,
    pairs_sha256: pairsSha,
    defects,
    counts,
    dropped: result.dropped,
    unverified: result.unverified,
    calibration_path: calibration,
    calibration_written: log.written,
    calibration_replaced: log.replaced,
    promotion_eligibility: promotionEligibility(log.rows),
  })
  const confirmed = result.defects.filter((defect) => defect.code === "meaning_drift_confirmed").length
  const summary = JSON.stringify({
    command: "fact meaning-check",
    status,
    defects: defects.length,
    confirmed,
    warn: result.defects.length - confirmed,
    dropped: result.dropped.length,
    unverified: result.unverified.length,
  })
  return { json: { ...record, out }, summary, exitCode }
}

/** @param {string[]} argv the arguments after `fact pairs` or `fact meaning-check` */
export function runFactMeaning(sub, argv) {
  const args = parseArgs(argv, { repeatable: ["verdicts"] })
  return sub === "pairs" ? runPairs(args) : runMeaningCheck(args)
}
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