@jphutchins/code-review 0.1.0-alpha.57 → 0.1.0-alpha.59

package/dist/index.js

@@ -63,7 +63,9 @@ var Confidence = t.refinement(t.number, (n) => n >= 0 && n <= 1, "Confidence");
 var Likelihood = t.refinement(t.number, (n) => n >= 0 && n <= 1, "Likelihood");
 var FiniteNumber = t.refinement(t.number, (n) => Number.isFinite(n), "FiniteNumber");
 var NonNegativePrice = t.refinement(t.number, (n) => n >= 0, "NonNegativePrice");
-var SCHEMA_VERSION_RE = /^(0|[1-9]\d*)\.(\d+)\.(\d+)(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+var SEMVER_SUFFIX = "(?:-[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)?(?:\\+[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)?";
+var SCHEMA_VERSION_RE = new RegExp(`^(0|[1-9]\\d*)\\.(\\d+)\\.(\\d+)${SEMVER_SUFFIX}$`);
+var anchoredSchemaVersionPattern = (version) => `^${version.split(".").slice(0, 2).join("\\.")}\\.[0-9]+${SEMVER_SUFFIX}$`;
 var SchemaVersion = t.refinement(
   t.string,
   (s) => SCHEMA_VERSION_RE.test(s),
@@ -74,11 +76,16 @@ var UriString = t.refinement(
   (s) => !/\s/.test(s) && URL.canParse(s),
   "UriString"
 );
+var strictExact = (name, shape, members) => {
+  const keys = new Set(members.flatMap((m) => Object.keys(m.props)));
+  return t.exact(
+    t.refinement(shape, (x) => Object.keys(x).every((k) => keys.has(k)), name)
+  );
+};
 var RuleUrlCodec = t.partial({
   code_url: UriString
 });
-var FindingRequired = t.type({
-  id: t.string,
+var FindingCoreRequired = t.type({
   path: t.string,
   start_line: LineNumber,
   end_line: LineNumber,
@@ -89,28 +96,25 @@ var FindingRequired = t.type({
   confidence: Confidence,
   likelihood: Likelihood
 });
+var FindingIdRequired = t.type({ id: t.string });
 var FindingOptional = t.partial({
   side: SideCodec,
   recommendation: t.string,
   patch: t.string
 });
-var FindingShape = t.intersection([FindingRequired, RuleUrlCodec, FindingOptional]);
-var EndGeStart = t.refinement(
-  FindingShape,
-  (f) => f.end_line >= f.start_line,
-  "EndGeStart"
-);
-var FINDING_KEYS = /* @__PURE__ */ new Set([
-  ...Object.keys(FindingRequired.props),
-  ...Object.keys(RuleUrlCodec.props),
-  ...Object.keys(FindingOptional.props)
+var EndGeStart = (shape) => t.refinement(shape, (f) => f.end_line >= f.start_line, "EndGeStart");
+var FindingShape = t.intersection([
+  FindingCoreRequired,
+  FindingIdRequired,
+  RuleUrlCodec,
+  FindingOptional
+]);
+var FindingCodec = strictExact("FindingStrict", EndGeStart(FindingShape), [
+  FindingCoreRequired,
+  FindingIdRequired,
+  RuleUrlCodec,
+  FindingOptional
 ]);
-var FindingStrict = t.refinement(
-  EndGeStart,
-  (f) => Object.keys(f).every((k) => FINDING_KEYS.has(k)),
-  "FindingStrict"
-);
-var FindingCodec = t.exact(FindingStrict);
 var SystemicRequired = t.type({
   title: t.string,
   description: t.string,
@@ -125,47 +129,34 @@ var SystemicOptional = t.partial({
   paths: t.array(t.string)
 });
 var SystemicProblemShape = t.intersection([SystemicRequired, RuleUrlCodec, SystemicOptional]);
-var SYSTEMIC_KEYS = /* @__PURE__ */ new Set([
-  ...Object.keys(SystemicRequired.props),
-  ...Object.keys(RuleUrlCodec.props),
-  ...Object.keys(SystemicOptional.props)
+var SystemicProblemCodec = strictExact("SystemicProblemStrict", SystemicProblemShape, [
+  SystemicRequired,
+  RuleUrlCodec,
+  SystemicOptional
 ]);
-var SystemicProblemStrict = t.refinement(
-  SystemicProblemShape,
-  (s) => Object.keys(s).every((k) => SYSTEMIC_KEYS.has(k)),
-  "SystemicProblemStrict"
+var ConsecutiveRounds = t.refinement(
+  t.number,
+  (n) => Number.isSafeInteger(n) && n >= 1,
+  "ConsecutiveRounds"
+);
+var StartRound = t.refinement(
+  t.number,
+  (n) => Number.isSafeInteger(n) && n >= 1,
+  "StartRound"
 );
-var SystemicProblemCodec = t.exact(SystemicProblemStrict);
 var RecurringShape = t.type({
   id: t.string,
-  consecutive_rounds: t.refinement(
-    t.number,
-    (n) => Number.isSafeInteger(n) && n >= 1,
-    "ConsecutiveRounds"
-  ),
-  start_round: t.refinement(
-    t.number,
-    (n) => Number.isSafeInteger(n) && n >= 1,
-    "StartRound"
-  )
+  consecutive_rounds: ConsecutiveRounds,
+  start_round: StartRound
 });
-var RECURRING_KEYS = new Set(Object.keys(RecurringShape.props));
-var RecurringCodec = t.refinement(
-  RecurringShape,
-  (r) => Object.keys(r).every((k) => RECURRING_KEYS.has(k)),
-  "RecurringStrict"
-);
+var RecurringCodec = strictExact("RecurringStrict", RecurringShape, [RecurringShape]);
 var ScopeMetastasisShape = t.type({
   decision_prompt: t.string,
   recurring: t.array(RecurringCodec)
 });
-var SCOPE_METASTASIS_KEYS = new Set(Object.keys(ScopeMetastasisShape.props));
-var ScopeMetastasisStrict = t.refinement(
-  ScopeMetastasisShape,
-  (s) => Object.keys(s).every((k) => SCOPE_METASTASIS_KEYS.has(k)),
-  "ScopeMetastasisStrict"
-);
-var ScopeMetastasisCodec = t.exact(ScopeMetastasisStrict);
+var ScopeMetastasisCodec = strictExact("ScopeMetastasisStrict", ScopeMetastasisShape, [
+  ScopeMetastasisShape
+]);
 var RoundNumber = t.refinement(
   t.number,
   (n) => Number.isSafeInteger(n) && n >= 1,
@@ -179,6 +170,7 @@ var idFrequencyCodec = (name) => new t.Type(
     const entries = [];
     for (const [k, v] of Object.entries(u)) {
       if (typeof v !== "number" || !Number.isSafeInteger(v) || v < 0) return t.failure(v, c);
+      if (v === 0) continue;
       entries.push([k, v]);
     }
     return t.success(Object.fromEntries(entries));
@@ -193,16 +185,10 @@ var ConvergenceRoundOptional = t.partial({
   sha: t.string
 });
 var ConvergenceRoundShape = t.intersection([ConvergenceRoundRequired, ConvergenceRoundOptional]);
-var CONVERGENCE_ROUND_KEYS = /* @__PURE__ */ new Set([
-  ...Object.keys(ConvergenceRoundRequired.props),
-  ...Object.keys(ConvergenceRoundOptional.props)
+var ConvergenceRoundCodec = strictExact("ConvergenceRoundStrict", ConvergenceRoundShape, [
+  ConvergenceRoundRequired,
+  ConvergenceRoundOptional
 ]);
-var ConvergenceRoundStrict = t.refinement(
-  ConvergenceRoundShape,
-  (r) => Object.keys(r).every((k) => CONVERGENCE_ROUND_KEYS.has(k)),
-  "ConvergenceRoundStrict"
-);
-var ConvergenceRoundCodec = t.exact(ConvergenceRoundStrict);
 var ConvergenceCoreShape = t.type({
   score: FiniteNumber,
   threshold: FiniteNumber,
@@ -210,16 +196,10 @@ var ConvergenceCoreShape = t.type({
 });
 var ConvergenceOptional = t.partial({ rounds: t.array(ConvergenceRoundCodec) });
 var ConvergenceShape = t.intersection([ConvergenceCoreShape, ConvergenceOptional]);
-var CONVERGENCE_KEYS = /* @__PURE__ */ new Set([
-  ...Object.keys(ConvergenceCoreShape.props),
-  ...Object.keys(ConvergenceOptional.props)
+var ConvergenceCodec = strictExact("ConvergenceStrict", ConvergenceShape, [
+  ConvergenceCoreShape,
+  ConvergenceOptional
 ]);
-var ConvergenceStrict = t.refinement(
-  ConvergenceShape,
-  (c) => Object.keys(c).every((k) => CONVERGENCE_KEYS.has(k)),
-  "ConvergenceStrict"
-);
-var ConvergenceCodec = t.exact(ConvergenceStrict);
 var LineDelta = t.refinement(
   t.number,
   (n) => Number.isInteger(n) && n >= 0,
@@ -269,102 +249,66 @@ var usableCountsMap = (v) => {
   );
   return entries.length === 0 ? void 0 : Object.fromEntries(entries);
 };
+var mergedCountsMaps = (ids, codes) => {
+  const idsMap = usableCountsMap(ids);
+  const codesMap = usableCountsMap(codes);
+  if (idsMap === void 0) return codesMap;
+  if (codesMap === void 0) return idsMap;
+  return { ...codesMap, ...idsMap };
+};
 var LegacyRuleCodec = t.partial({
   code: t.string,
   id: t.string,
   code_url: UriString
 });
-var FindingShapeV09 = t.intersection([
-  t.type({
-    path: t.string,
-    start_line: LineNumber,
-    end_line: LineNumber,
-    severity: SeverityCodec,
-    title: t.string,
-    description: t.string,
-    reasoning: t.string,
-    confidence: Confidence,
-    likelihood: Likelihood
-  }),
-  LegacyRuleCodec,
-  t.partial({
-    side: SideCodec,
-    recommendation: t.string,
-    patch: t.string
-  })
-]);
-var EndGeStartV09 = t.refinement(
-  FindingShapeV09,
-  (f) => f.end_line >= f.start_line,
-  "EndGeStartV09"
-);
-var FindingCodecV09 = t.exact(EndGeStartV09);
+var FindingShapeV09 = t.intersection([FindingCoreRequired, LegacyRuleCodec, FindingOptional]);
+var FindingCodecV09 = t.exact(EndGeStart(FindingShapeV09));
 var SystemicV09Optional = t.partial({
   finding_codes: t.array(t.string),
   finding_ids: t.array(t.string),
   paths: t.array(t.string)
 });
 var SystemicV09Shape = t.intersection([SystemicRequired, LegacyRuleCodec, SystemicV09Optional]);
-var SYSTEMIC_V09_KEYS = /* @__PURE__ */ new Set([
-  ...Object.keys(SystemicRequired.props),
-  ...Object.keys(LegacyRuleCodec.props),
-  ...Object.keys(SystemicV09Optional.props)
-]);
-var SystemicV09Strict = t.refinement(
-  SystemicV09Shape,
-  (s) => Object.keys(s).every((k) => SYSTEMIC_V09_KEYS.has(k)),
-  "SystemicV09Strict"
-);
-var SystemicProblemCodecV09 = t.exact(SystemicV09Strict);
-var RecurringV09Shape = t.intersection([
-  t.partial({ code: t.string, id: t.string }),
-  t.type({
-    consecutive_rounds: t.refinement(
-      t.number,
-      (n) => Number.isSafeInteger(n) && n >= 1,
-      "ConsecutiveRoundsV09"
-    ),
-    start_round: t.refinement(
-      t.number,
-      (n) => Number.isSafeInteger(n) && n >= 1,
-      "StartRoundV09"
-    )
-  })
+var SystemicProblemCodecV09 = strictExact("SystemicV09Strict", SystemicV09Shape, [
+  SystemicRequired,
+  LegacyRuleCodec,
+  SystemicV09Optional
 ]);
+var RecurringV09Identity = t.partial({ code: t.string, id: t.string });
+var RecurringV09Counts = t.type({
+  consecutive_rounds: ConsecutiveRounds,
+  start_round: StartRound
+});
+var RecurringV09Shape = t.intersection([RecurringV09Identity, RecurringV09Counts]);
 var ScopeMetastasisV09Shape = t.type({
   decision_prompt: t.string,
   recurring: t.array(RecurringV09Shape)
 });
-var SCOPE_METASTASIS_V09_KEYS = new Set(Object.keys(ScopeMetastasisV09Shape.props));
-var ScopeMetastasisV09Strict = t.refinement(
-  ScopeMetastasisV09Shape,
-  (s) => Object.keys(s).every((k) => SCOPE_METASTASIS_V09_KEYS.has(k)),
-  "ScopeMetastasisV09Strict"
-);
-var ScopeMetastasisCodecV09 = t.exact(ScopeMetastasisV09Strict);
+var ScopeMetastasisCodecV09 = strictExact("ScopeMetastasisV09Strict", ScopeMetastasisV09Shape, [
+  ScopeMetastasisV09Shape
+]);
 var CodeFrequencyV09 = idFrequencyCodec("CodeFrequencyV09");
+var ConvergenceRoundV09Optional = t.partial({
+  score: FiniteNumber,
+  codes: CodeFrequencyV09,
+  ids: CodeFrequencyV09,
+  sha: t.string
+});
 var ConvergenceRoundV09Shape = t.intersection([
-  t.type({ round: RoundNumber }),
-  t.partial({ score: FiniteNumber, codes: CodeFrequencyV09, ids: CodeFrequencyV09, sha: t.string })
+  ConvergenceRoundRequired,
+  ConvergenceRoundV09Optional
 ]);
-var CONVERGENCE_ROUND_V09_KEYS = /* @__PURE__ */ new Set(["round", "score", "codes", "ids", "sha"]);
-var ConvergenceRoundV09Strict = t.refinement(
+var ConvergenceRoundCodecV09 = strictExact(
+  "ConvergenceRoundV09Strict",
   ConvergenceRoundV09Shape,
-  (r) => Object.keys(r).every((k) => CONVERGENCE_ROUND_V09_KEYS.has(k)),
-  "ConvergenceRoundV09Strict"
+  [ConvergenceRoundRequired, ConvergenceRoundV09Optional]
 );
-var ConvergenceRoundCodecV09 = t.exact(ConvergenceRoundV09Strict);
-var ConvergenceV09Shape = t.intersection([
+var ConvergenceV09Optional = t.partial({ rounds: t.array(ConvergenceRoundCodecV09) });
+var ConvergenceV09Shape = t.intersection([ConvergenceCoreShape, ConvergenceV09Optional]);
+var ConvergenceCodecV09 = strictExact("ConvergenceV09Strict", ConvergenceV09Shape, [
   ConvergenceCoreShape,
-  t.partial({ rounds: t.array(ConvergenceRoundCodecV09) })
+  ConvergenceV09Optional
 ]);
-var CONVERGENCE_V09_KEYS = /* @__PURE__ */ new Set([...Object.keys(ConvergenceCoreShape.props), "rounds"]);
-var ConvergenceV09Strict = t.refinement(
-  ConvergenceV09Shape,
-  (c) => Object.keys(c).every((k) => CONVERGENCE_V09_KEYS.has(k)),
-  "ConvergenceV09Strict"
-);
-var ConvergenceCodecV09 = t.exact(ConvergenceV09Strict);
 var FindingsV09Shape = t.intersection([
   t.type({
     // Any pre-0.10 minor — the registry dispatches on major.minor before decoding, so the codec
@@ -417,7 +361,7 @@ var normalizeV09 = (doc) => {
     converged: doc.convergence.converged,
     ...doc.convergence.rounds !== void 0 ? {
       rounds: doc.convergence.rounds.map((r) => {
-        const ids = usableCountsMap(r.ids) ?? usableCountsMap(r.codes);
+        const ids = mergedCountsMaps(r.ids, r.codes);
         return {
           round: r.round,
           ...r.score !== void 0 ? { score: r.score } : {},
@@ -488,26 +432,17 @@ var FlatModelPricesShape = t.type({
   cache_read: NonNegativePrice,
   cache_write: NonNegativePrice
 });
-var FLAT_PRICE_KEYS = new Set(Object.keys(FlatModelPricesShape.props));
-var FlatModelPricesStrict = t.refinement(
-  FlatModelPricesShape,
-  (p) => Object.keys(p).every((k) => FLAT_PRICE_KEYS.has(k)),
-  "FlatModelPricesStrict"
-);
-var FlatModelPricesCodec = t.exact(FlatModelPricesStrict);
+var FlatModelPricesCodec = strictExact("FlatModelPricesStrict", FlatModelPricesShape, [
+  FlatModelPricesShape
+]);
 var UTC_HHMM_RE = /^([01][0-9]|2[0-3]):[0-5][0-9]$/;
 var UtcHHMM = t.refinement(t.string, (s) => UTC_HHMM_RE.test(s), "UtcHHMM");
-var PriceSlotShape = t.intersection([
-  t.type({ utc_from: UtcHHMM, utc_to: UtcHHMM }),
+var PriceSlotAnchor = t.type({ utc_from: UtcHHMM, utc_to: UtcHHMM });
+var PriceSlotShape = t.intersection([PriceSlotAnchor, FlatModelPricesShape]);
+var PriceSlotCodec = strictExact("PriceSlotStrict", PriceSlotShape, [
+  PriceSlotAnchor,
   FlatModelPricesShape
 ]);
-var PRICE_SLOT_KEYS = /* @__PURE__ */ new Set(["utc_from", "utc_to", ...Object.keys(FlatModelPricesShape.props)]);
-var PriceSlotStrict = t.refinement(
-  PriceSlotShape,
-  (s) => Object.keys(s).every((k) => PRICE_SLOT_KEYS.has(k)),
-  "PriceSlotStrict"
-);
-var PriceSlotCodec = t.exact(PriceSlotStrict);
 var NonEmptyPriceSlots = t.refinement(
   t.array(PriceSlotCodec),
   (a) => a.length >= 1,
@@ -516,16 +451,10 @@ var NonEmptyPriceSlots = t.refinement(
 var SlottedRequired = t.type({ slots: NonEmptyPriceSlots });
 var SlottedOptional = t.partial({ weekend_slots: NonEmptyPriceSlots });
 var SlottedShape = t.intersection([SlottedRequired, SlottedOptional]);
-var SLOTTED_KEYS = /* @__PURE__ */ new Set([
-  ...Object.keys(SlottedRequired.props),
-  ...Object.keys(SlottedOptional.props)
+var SlottedModelPricesCodec = strictExact("SlottedModelPricesStrict", SlottedShape, [
+  SlottedRequired,
+  SlottedOptional
 ]);
-var SlottedModelPricesStrict = t.refinement(
-  SlottedShape,
-  (s) => Object.keys(s).every((k) => SLOTTED_KEYS.has(k)),
-  "SlottedModelPricesStrict"
-);
-var SlottedModelPricesCodec = t.exact(SlottedModelPricesStrict);
 var ModelPricesCodec = t.union([FlatModelPricesCodec, SlottedModelPricesCodec]);
 var PriceMapCodec = t.type({
   _updated: t.string,
@@ -828,10 +757,13 @@ var isSeverityCounts = (u) => typeof u === "object" && u !== null && SEVERITIES.
 var MAX_IDS_PER_ROUND = 8;
 var hasId = (ids, code) => ids !== void 0 && Object.prototype.hasOwnProperty.call(ids, code);
 var escapeCodeBackticks = (code) => code.replace(/`/g, "-").replace(/\r?\n/g, " ");
-var normalizeIdCounts = (ids, priorCodes) => {
-  const entries = Object.entries(usableCountsMap(ids) ?? {});
+var normalizeIdCounts = (ids, priorCodes, preferredKeys, preValidated = false) => {
+  const entries = Object.entries((preValidated ? ids : usableCountsMap(ids)) ?? {});
   if (entries.length === 0) return void 0;
   const sorted = entries.sort((a, b) => {
+    const aPreferred = preferredKeys?.has(a[0]) === true ? 1 : 0;
+    const bPreferred = preferredKeys?.has(b[0]) === true ? 1 : 0;
+    if (aPreferred !== bPreferred) return bPreferred - aPreferred;
     if (b[1] !== a[1]) return b[1] - a[1];
     const aPrior = hasId(priorCodes, a[0]) ? 1 : 0;
     const bPrior = hasId(priorCodes, b[0]) ? 1 : 0;
@@ -851,7 +783,12 @@ var parseRounds = (body) => {
   let priorCodes;
   for (const u of decoded.filter(isSeverityCounts)) {
     const rec = u;
-    const codes = normalizeIdCounts(rec["ids"], priorCodes) ?? normalizeIdCounts(rec["codes"], priorCodes);
+    const codes = normalizeIdCounts(
+      mergedCountsMaps(rec["ids"], rec["codes"]),
+      priorCodes,
+      new Set(Object.keys(usableCountsMap(rec["ids"]) ?? {})),
+      true
+    );
     priorCodes = codes;
     const sha = rec["sha"];
     const shaStr = typeof sha === "string" && sha !== "" ? sha : void 0;
@@ -1084,7 +1021,7 @@ var withLegacyConvergenceIds = (raw) => {
   const mapped = rounds.map((r) => {
     if (typeof r !== "object" || r === null) return r;
     const round = r;
-    const ids = usableCountsMap(round["ids"]) ?? usableCountsMap(round["codes"]);
+    const ids = mergedCountsMaps(round["ids"], round["codes"]);
     if (ids === void 0) {
       return round["ids"] !== void 0 || round["codes"] !== void 0 ? Object.fromEntries(Object.entries(round).filter(([k]) => k !== "ids" && k !== "codes")) : round;
     }
@@ -1446,10 +1383,29 @@ var answeredRegistryFrom = (comments, botLogin) => {
   }
   return [...byKey.values()];
 };
-var matches = (f, e) => e.code === resolveFindingId(f) || isSynthesizedFindingId(e.code) && e.title === f.title;
-var isVerbatimReRaise = (f, e) => f.title === e.title && f.description === e.description && f.reasoning === e.reasoning && f.severity === e.severity && f.path === e.path && (f.patch ?? null) === e.patch;
-var isAnsweredDrop = (f, e) => matches(f, e) && isVerbatimReRaise(f, e) && f.severity !== "critical";
+var isSynthesizedTitleMatch = (f, e) => isSynthesizedFindingId(e.code) && e.title === f.title;
+var matches = (resolvedId, f, e) => e.code === resolvedId || isSynthesizedTitleMatch(f, e);
+var VERBATIM_FIELDS = ["title", "description", "reasoning", "severity", "path", "patch"];
+var verbatimFieldEqual = (f, e, field) => field === "patch" ? (f.patch ?? null) === e.patch : f[field] === e[field];
+var isVerbatimReRaise = (f, e) => VERBATIM_FIELDS.every((field) => verbatimFieldEqual(f, e, field));
+var isAnsweredDrop = (resolvedId, f, e) => matches(resolvedId, f, e) && isVerbatimReRaise(f, e) && f.severity !== "critical";
+var verbatimMatchCount = (f, e) => VERBATIM_FIELDS.reduce((count, field) => count + (verbatimFieldEqual(f, e, field) ? 1 : 0), 0);
 var answeredNoteKey = (f) => f.id !== "" ? f.id : `title:${f.title}`;
+var NO_TITLE_MATCH = { entry: void 0, score: -1 };
+var bestTitleMatch = (f, registry) => {
+  let best;
+  let bestScore = -1;
+  for (const e of registry) {
+    if (!isSynthesizedTitleMatch(f, e)) continue;
+    const score = verbatimMatchCount(f, e);
+    if (score > bestScore) {
+      best = e;
+      bestScore = score;
+      if (score === VERBATIM_FIELDS.length) break;
+    }
+  }
+  return { entry: best, score: bestScore };
+};
 var answeredNote = (e) => `Re-raised; prior answer at ${e.replyUrl} by ${e.replyAuthor} \u2014 cite the new evidence that invalidates it.`;
 var applyAnswered = (findings, registry) => {
   const kept = [];
@@ -1458,14 +1414,18 @@ var applyAnswered = (findings, registry) => {
   const droppedFindingIds = [];
   let droppedCount = 0;
   for (const f of findings) {
-    const entry = registry.find((e) => e.code === resolveFindingId(f)) ?? registry.find((e) => isSynthesizedFindingId(e.code) && e.title === f.title);
+    const resolvedId = resolveFindingId(f);
+    const idMatch = registry.find((e) => e.code === resolvedId);
+    const { entry: titleMatch, score: titleScore } = idMatch === void 0 ? bestTitleMatch(f, registry) : NO_TITLE_MATCH;
+    const entry = idMatch ?? titleMatch;
     if (entry === void 0) {
       kept.push(f);
       continue;
     }
-    if (isAnsweredDrop(f, entry)) {
+    const dropped = (idMatch !== void 0 ? isVerbatimReRaise(f, entry) : titleScore === VERBATIM_FIELDS.length) && f.severity !== "critical";
+    if (dropped) {
       droppedByEntry.set(entry.replyId, entry);
-      droppedFindingIds.push(resolveFindingId(f));
+      droppedFindingIds.push(resolvedId);
       droppedCount += 1;
     } else {
       kept.push(f);
@@ -3179,30 +3139,44 @@ var priorIdsFrom = (doc) => {
   });
   return [...idsOf("findings", false), ...idsOf("systemic_problems", true)];
 };
+var appendBestEffort = (path, label, body) => {
+  if (path === void 0 || path === "") return;
+  try {
+    appendFileSync(path, body);
+  } catch (err) {
+    process.stderr.write(`Warning: could not write ${label}: ${errMsg(err)}
+`);
+  }
+};
+var writePostedSignal = (value) => {
+  appendBestEffort(
+    process.env["GITHUB_OUTPUT"],
+    "the posted signal to GITHUB_OUTPUT",
+    `posted=${value ? "true" : "false"}
+`
+  );
+};
 var appendRunSummary = (summaryPath, body) => {
   if (summaryPath === void 0 || summaryPath === "") return;
   const rendered = body();
-  try {
-    appendFileSync(summaryPath, `
+  appendBestEffort(summaryPath, "the run summary", `
 ${rendered}
 `);
-  } catch (err) {
-    process.stderr.write(`Warning: could not write the run summary: ${errMsg(err)}
-`);
-  }
 };
-var upsertSticky = async (repo, prNumber, existing, body, ghApi) => {
+var upsertSticky = async (repo, prNumber, existing, body, ghApi, signal = false) => {
   if (existing !== null) {
     const patched = await patchComment(repo, existing.id, body, ghApi);
     process.stderr.write(
       `Updated sticky comment #${String(existing.id)} on PR #${String(prNumber)}
 `
     );
+    if (signal) writePostedSignal(true);
     return { id: existing.id, url: patched?.html_url };
   }
   const posted = await postComment(repo, prNumber, body, ghApi);
   process.stderr.write(`Posted new sticky comment on PR #${String(prNumber)}
 `);
+  if (signal && posted !== null) writePostedSignal(true);
   return posted ? { id: posted.id, url: posted.html_url } : null;
 };
 var isBotReview = (r) => typeof r === "object" && r !== null && typeof r.id === "number" && typeof r.state === "string" && typeof r.user?.login === "string";
@@ -3325,6 +3299,7 @@ var post = async (input, ghApi = runGhApi, readArtifact = ghArtifactReader) => {
   if (resolution.kind === "none") {
     process.stderr.write(`No open PR for ${input.headSha} \u2014 nothing to post
 `);
+    writePostedSignal(false);
     process.exit(0);
   }
   if (resolution.kind === "not-open") {
@@ -3332,6 +3307,7 @@ var post = async (input, ghApi = runGhApi, readArtifact = ghArtifactReader) => {
       `PR #${String(resolution.prNumber)} for ${input.headSha} is not open (state: ${resolution.state}) \u2014 nothing to post
 `
     );
+    writePostedSignal(false);
     process.exit(0);
   }
   const prNumber = resolution.prNumber;
@@ -3372,6 +3348,7 @@ var post = async (input, ghApi = runGhApi, readArtifact = ghArtifactReader) => {
     process.stderr.write(
       message ?? "Review did not complete and the sticky already reflects a completed review \u2014 leaving it in place\n"
     );
+    writePostedSignal(true);
     process.exit(0);
   };
   const logAnsweredDrops = () => {
@@ -3399,7 +3376,7 @@ ${dropNote}` : ""}`,
         sticky.body
       )
     );
-    await upsertSticky(input.repo, prNumber, sticky, body, ghApi);
+    await upsertSticky(input.repo, prNumber, sticky, body, ghApi, true);
     process.exit(0);
   };
   const prices = JSON.parse(readFileSync(input.pricesPath, "utf-8"));
@@ -3477,7 +3454,8 @@ ${dropNote}` : ""}`,
       prNumber,
       existingSticky,
       renderNotice("The diff for this PR is empty \u2014 nothing to review.", discussion),
-      ghApi
+      ghApi,
+      true
     );
     process.exit(0);
   }
@@ -3490,7 +3468,8 @@ ${dropNote}` : ""}`,
       prNumber,
       existingSticky,
       renderNotice(noticeMessageFor(findingsResult), discussion),
-      ghApi
+      ghApi,
+      true
     );
     process.exit(0);
   }
@@ -3615,7 +3594,7 @@ ${dropNote}` : ""}`,
         orphanedUnresolvable: orphanResolveFailed
       })
     );
-    await upsertSticky(input.repo, prNumber, existingSticky, body, ghApi);
+    await upsertSticky(input.repo, prNumber, existingSticky, body, ghApi, true);
     appendRunSummary(process.env["GITHUB_STEP_SUMMARY"], () => body);
     if (inlineRequested) {
       process.stderr.write(
@@ -3741,7 +3720,8 @@ ${dropNote}` : ""}`,
     prNumber,
     existingSticky,
     renderBody(initialDisposition),
-    ghApi
+    ghApi,
+    true
   );
   const priorInlineComments = await listPriorBotCommentIds(
     input.repo,
@@ -5489,11 +5469,20 @@ var deadlineCmd = defineCommand({
   }
 });
 var derivedSchemaVersion = (kind, raw) => kind === "findings" ? declaredVersion(raw) : void 0;
-var printableSchema = (schemaPath) => {
+var printableSchema = (schemaPath, pinVersion) => {
   const schema = JSON.parse(readFileSync(schemaPath, "utf-8"));
   const enforcementSchema = Object.fromEntries(
     Object.entries(schema).filter(([key2]) => key2 !== "$schema")
   );
+  if (!pinVersion) return JSON.stringify(enforcementSchema, null, 2);
+  const properties = enforcementSchema["properties"];
+  const schemaVersion = typeof properties === "object" && properties !== null ? properties["schema_version"] : void 0;
+  if (typeof schemaVersion === "object" && schemaVersion !== null) {
+    properties["schema_version"] = {
+      ...schemaVersion,
+      pattern: anchoredSchemaVersionPattern(DEFAULT_SCHEMA_VERSION)
+    };
+  }
   return JSON.stringify(enforcementSchema, null, 2);
 };
 var validateCmd = defineCommand({
@@ -5539,7 +5528,7 @@ var validateCmd = defineCommand({
         process.stderr.write(
           `
 The ${kind} document must conform to this schema (the field descriptions are the authoritative spec \u2014 match the property names exactly):
-${printableSchema(schemaPath)}
+${printableSchema(schemaPath, kind === "findings" && schemaPath === schemaPathFor(kind))}
 `
         );
       }
@@ -5672,9 +5661,10 @@ var seedDraftCmd = defineCommand({
       const resolved = resolvedPriorValue(strippedPrior);
       const doc = resolved === null ? strippedPrior : {
         ...resolved,
-        findings: answeredRegistry !== null && answeredRegistry.length > 0 ? resolved.findings.filter(
-          (f) => !answeredRegistry.some((e) => isAnsweredDrop(f, e))
-        ) : resolved.findings
+        findings: answeredRegistry !== null && answeredRegistry.length > 0 ? resolved.findings.filter((f) => {
+          const resolvedId = resolveFindingId(f);
+          return !answeredRegistry.some((e) => isAnsweredDrop(resolvedId, f, e));
+        }) : resolved.findings
       };
       const carried = doc["scope_metastasis"];
       if (ScopeMetastasisCodec.decode(carried)._tag === "Right") return doc;
@@ -6008,7 +5998,26 @@ var printSchemaCmd = defineCommand({
   run: async ({ args }) => {
     const schemaKind = requireSchemaKind(args.name);
     const schemaPath = requireSchemaPath(schemaKind, args["schema-version"]);
-    process.stdout.write(`${printableSchema(schemaPath)}
+    process.stdout.write(
+      `${printableSchema(schemaPath, schemaKind === "findings" && schemaPath === schemaPathFor(schemaKind))}
+`
+    );
+  }
+});
+var defaultVersionCmd = defineCommand({
+  meta: {
+    name: "default-version",
+    description: "Print the in-force schema version the installed registry resolves by default \u2014 the value a draft should stamp as schema_version"
+  },
+  args: {
+    kind: {
+      type: "string",
+      description: "Schema kind (findings | triage | prices); default: findings"
+    }
+  },
+  run: async ({ args }) => {
+    const kind = requireSchemaKind(args.kind || "findings");
+    process.stdout.write(`${defaultVersion(kind)}
 `);
   }
 });
@@ -6679,6 +6688,7 @@ var main = defineCommand({
     extract: extractCmd,
     "validate-patches": validatePatchesCmd,
     "print-schema": printSchemaCmd,
+    "default-version": defaultVersionCmd,
     "stop-gate": stopGateCmd,
     "budget-hook": budgetHookCmd,
     "print-settings": printSettingsCmd,
@@ -6690,6 +6700,6 @@ if (!process.env["VITEST"]) {
   await runMain(main);
 }
 
-export { main, snapshotIfValid };
+export { main, printableSchema, snapshotIfValid };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map