crysk 0.3.1 → 0.3.2
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +9 -5
- package/dist/SKILL-6j27707y.md +140 -0
- package/dist/SKILL-816621e5.md +74 -0
- package/dist/SKILL-bnh7nrjz.md +74 -0
- package/dist/SKILL-fv8x6hhx.md +140 -0
- package/dist/SKILL-nv32jpc5.md +74 -0
- package/dist/SKILL-qnfc8yp3.md +539 -0
- package/dist/SKILL-xr56f0b6.md +140 -0
- package/dist/SKILL-yz6wk92g.md +542 -0
- package/dist/ci-admission-09k2ba89.md +126 -0
- package/dist/ci-admission-f19qh39t.md +128 -0
- package/dist/ci-admission-tcqsj7b2.md +126 -0
- package/dist/cli.js +1831 -1150
- package/dist/index.js +1464 -911
- package/dist/materiality-f1qwnvg1.md +27 -0
- package/package.json +3 -2
- package/prompts/materiality.md +27 -0
- package/skills/crysk/SKILL.md +2 -2
- package/skills/crysk-ci-setup/SKILL.md +13 -7
- package/skills/crysk-ci-setup/references/ci-admission.md +4 -0
- package/skills/crysk-loop/SKILL.md +32 -5
- package/src/asset-manifest.ts +2 -0
- package/src/assets.ts +4 -1
- package/src/brand.ts +11 -9
- package/src/ci/cli-record.ts +1 -1
- package/src/ci/gates.ts +31 -0
- package/src/ci/outcome.ts +2 -1
- package/src/ci/override.ts +11 -10
- package/src/ci/publish.ts +44 -103
- package/src/ci/reporter.ts +34 -5
- package/src/ci/review-levels.ts +21 -0
- package/src/ci/setup.ts +1 -2
- package/src/commands/post.ts +17 -0
- package/src/compare/loop.ts +356 -0
- package/src/compare/materiality.ts +266 -0
- package/src/compare/noise.ts +166 -0
- package/src/diversity/projection.ts +3 -0
- package/src/index.ts +1 -1
- package/src/model/routing.ts +62 -0
- package/src/pr/admission.ts +13 -1
- package/src/pr/discovery.ts +17 -5
- package/src/pr/inline.ts +15 -1
- package/src/pr/plan.ts +5 -0
- package/src/pr/post-floor.ts +30 -0
- package/src/pr/posting.ts +4 -0
- package/src/pr/pr-status.ts +14 -0
- package/src/pr/pr.ts +50 -34
- package/src/pr/preflight.ts +2 -2
- package/src/pr/publish-outcome.ts +4 -0
- package/src/pr/review-pr.ts +65 -26
- package/src/pr/teardown.ts +1 -1
- package/src/rereview/prepare.ts +16 -0
- package/src/rereview/state.ts +206 -25
- package/src/review/boundary.ts +4 -1
- package/src/review/dedupe.ts +48 -4
- package/src/review/findings.ts +47 -1
- package/src/review/materiality-gate.ts +134 -0
- package/src/review/pipeline.ts +521 -41
- package/src/review/preflight.ts +69 -0
- package/src/review/report.ts +73 -10
- package/src/review/review.ts +16 -0
- package/src/review/route-preflight.ts +29 -1
- package/src/review/run.ts +2 -0
- package/src/ui/config.ts +8 -0
- package/src/updater.ts +1 -1
package/src/rereview/state.ts
CHANGED
|
@@ -19,7 +19,13 @@ import {
|
|
|
19
19
|
identityFromFinding,
|
|
20
20
|
identityFromLocs,
|
|
21
21
|
} from "#rereview/identity";
|
|
22
|
-
import
|
|
22
|
+
import {
|
|
23
|
+
deriveTier,
|
|
24
|
+
type Finding,
|
|
25
|
+
isCausallyExempt,
|
|
26
|
+
type Severity,
|
|
27
|
+
} from "#review/findings";
|
|
28
|
+
import { isSafetyProtected } from "#review/materiality-gate";
|
|
23
29
|
import { findMarker, MARKER_BRAND_PATTERN, MARKER_OPEN } from "../brand";
|
|
24
30
|
import {
|
|
25
31
|
type FindingChannel,
|
|
@@ -407,6 +413,7 @@ export function assembleLive(input: {
|
|
|
407
413
|
tier: gatePrior.tier,
|
|
408
414
|
locs: row.locs,
|
|
409
415
|
status,
|
|
416
|
+
claim: gatePrior.claim,
|
|
410
417
|
});
|
|
411
418
|
}
|
|
412
419
|
// Only a triage-driven settlement persists, as `carried`: the author's
|
|
@@ -473,9 +480,22 @@ export function assembleLive(input: {
|
|
|
473
480
|
// - verified-gone: the verifier refuted the finding, or every file it names
|
|
474
481
|
// was deleted (classifyPrior settles that as verified-gone).
|
|
475
482
|
// - ci-dismissed: the author's latest dismissal, upheld by the CI adjudicator (src/triage/adjudication.ts, D5).
|
|
476
|
-
//
|
|
477
|
-
//
|
|
478
|
-
//
|
|
483
|
+
// - a materiality demotion: this run re-found the finding as blocking and the
|
|
484
|
+
// materiality gate judged it immaterial (review/materiality-gate.ts). The
|
|
485
|
+
// demoted survivor pairs with one blocking row at its spot and releases it,
|
|
486
|
+
// and the state merge re-tiers that row advisory (materialityReleasedIds).
|
|
487
|
+
// This carries the same identity risk a blocking survivor already accepts:
|
|
488
|
+
// the survivor was blocking on its own merits before the judge spoke. The
|
|
489
|
+
// gate tracks the current verdict, so a judge that flips back to material
|
|
490
|
+
// on a later head blocks again. One exception keeps the materiality gate's
|
|
491
|
+
// safety guard whole: the guard reads the survivor's claim, and the window
|
|
492
|
+
// can pair it with a different issue, so a prior whose own claim or path
|
|
493
|
+
// the guard protects (auth, secrets, data loss), or whose claim is unknown,
|
|
494
|
+
// is never released.
|
|
495
|
+
// Nothing else this run concludes about a prior lowers it. A plain advisory
|
|
496
|
+
// survivor at a blocking prior's spot does not clear that prior: identity
|
|
497
|
+
// matching is a 5-line window, so a different issue can sit there, and the
|
|
498
|
+
// gate fails closed.
|
|
479
499
|
// A real fix leaves the count when the re-review VERIFIES it gone, and
|
|
480
500
|
// `/pr-hero override` covers a team that accepts the finding.
|
|
481
501
|
// A self-asserted triage tag never leaves the count (S7). `misclassified`
|
|
@@ -488,33 +508,97 @@ export function assembleLive(input: {
|
|
|
488
508
|
// Dedupe key. Two rules, both stated so a reader can check them:
|
|
489
509
|
// - a gate row is one prior, keyed by its id (R###). A duplicate row for the
|
|
490
510
|
// same id counts once;
|
|
491
|
-
// -
|
|
511
|
+
// - a BLOCKING survivor pairs with at most one gate row, by
|
|
492
512
|
// the identity the worsening step already uses (identityFromLocs of the
|
|
493
513
|
// prior against identityFromFinding of the survivor). It takes the first
|
|
494
514
|
// unpaired match in PAIR_PREFERENCE order: a blocking row, an unrecoverable
|
|
495
515
|
// row, then an advisory row. A paired row is carried by its survivor and not
|
|
496
|
-
// counted again; a blocking survivor counts by its own tier.
|
|
497
|
-
// survivor
|
|
516
|
+
// counted again; a blocking survivor counts by its own tier. A
|
|
517
|
+
// materiality-demoted survivor then pairs with at most one still-unpaired
|
|
518
|
+
// blocking row, never an unrecoverable or advisory one, releases it, and
|
|
519
|
+
// counts nothing itself (gatePairing). Any other advisory survivor never
|
|
520
|
+
// pairs, so it cannot remove a blocking prior from the count.
|
|
498
521
|
// One-to-one is the fail-closed choice: two priors at one spot and one survivor
|
|
499
522
|
// count as two, because the survivor can be only one of them.
|
|
500
523
|
//
|
|
501
524
|
// Unrecoverable tiers ARE counted, as blocking. A prior whose tier could not be
|
|
502
525
|
// read back is unclassified, and the fail-visible rule (classify.ts) and S7 both
|
|
503
526
|
// forbid a green gate on a finding we cannot classify. Only a verifier verdict or
|
|
504
|
-
// a deleted file lowers such a row, and
|
|
505
|
-
//
|
|
527
|
+
// a deleted file lowers such a row, and no advisory survivor at the same spot,
|
|
528
|
+
// demoted or not, pairs with it.
|
|
506
529
|
|
|
507
530
|
export interface GateRow {
|
|
508
531
|
id: string;
|
|
509
532
|
tier: RecoveredTier;
|
|
510
533
|
locs: readonly string[];
|
|
511
534
|
status: GateStatus;
|
|
535
|
+
// The prior's claim, read only by the materiality release: a prior the
|
|
536
|
+
// materiality gate's safety guard protects is never released. Absent fails
|
|
537
|
+
// closed, the prior cannot be released, and so does a blank one.
|
|
538
|
+
claim?: string;
|
|
512
539
|
}
|
|
513
540
|
|
|
541
|
+
// The causal fields are optional so a caller that only has identity and tier
|
|
542
|
+
// still counts correctly: a survivor without them is never causally demoted, so
|
|
543
|
+
// it releases nothing (fail closed). doc.findings carries all of them.
|
|
514
544
|
export type GateSurvivor = Pick<
|
|
515
545
|
Finding,
|
|
516
|
-
"path" | "line" | "proof_refs" | "tier"
|
|
517
|
-
|
|
546
|
+
"path" | "line" | "proof_refs" | "tier" | "materiality"
|
|
547
|
+
> &
|
|
548
|
+
Partial<
|
|
549
|
+
Pick<
|
|
550
|
+
Finding,
|
|
551
|
+
| "severity"
|
|
552
|
+
| "evidence_class"
|
|
553
|
+
| "refuter_verdict"
|
|
554
|
+
| "causal_disposition"
|
|
555
|
+
| "claim"
|
|
556
|
+
>
|
|
557
|
+
>;
|
|
558
|
+
|
|
559
|
+
// A survivor demoted from blocking: advisory now, and blocking but for one
|
|
560
|
+
// rule. Either the materiality gate's immaterial verdict
|
|
561
|
+
// (review/materiality-gate.ts), or #457's causal rule: the PR did not cause it.
|
|
562
|
+
// These are the only advisory survivors that pair, and only with a blocking row
|
|
563
|
+
// (see the note above GateRow). The causal case asks deriveTier what the
|
|
564
|
+
// finding would be as `introduced`, so a pre-existing finding that would have
|
|
565
|
+
// been advisory anyway (an unrefuted inferential one) releases nothing. A
|
|
566
|
+
// `not_submitted` survivor never counts as demoted: on a run the ceiling cut
|
|
567
|
+
// short, deriveTier demoted it for the missing check (refuterCutShort), which
|
|
568
|
+
// this row cannot see, so the recompute would call it blocking and release a
|
|
569
|
+
// prior it never earned. Failing closed costs one prior staying counted.
|
|
570
|
+
function isDemotedFromBlocking(survivor: GateSurvivor): boolean {
|
|
571
|
+
if (survivor.tier !== "advisory") return false;
|
|
572
|
+
if (survivor.materiality?.label === "immaterial") return true;
|
|
573
|
+
const {
|
|
574
|
+
severity,
|
|
575
|
+
evidence_class,
|
|
576
|
+
refuter_verdict,
|
|
577
|
+
causal_disposition,
|
|
578
|
+
claim,
|
|
579
|
+
} = survivor;
|
|
580
|
+
if (
|
|
581
|
+
severity === undefined ||
|
|
582
|
+
evidence_class === undefined ||
|
|
583
|
+
refuter_verdict === undefined ||
|
|
584
|
+
refuter_verdict === "not_submitted" ||
|
|
585
|
+
causal_disposition === undefined ||
|
|
586
|
+
claim === undefined
|
|
587
|
+
)
|
|
588
|
+
return false;
|
|
589
|
+
const finding = {
|
|
590
|
+
severity,
|
|
591
|
+
evidence_class,
|
|
592
|
+
refuter_verdict,
|
|
593
|
+
causal_disposition,
|
|
594
|
+
claim,
|
|
595
|
+
path: survivor.path,
|
|
596
|
+
};
|
|
597
|
+
return (
|
|
598
|
+
isCausallyExempt(finding) &&
|
|
599
|
+
deriveTier({ ...finding, causal_disposition: "introduced" }) === "blocking"
|
|
600
|
+
);
|
|
601
|
+
}
|
|
518
602
|
|
|
519
603
|
// The order a blocking survivor pairs with a prior: its own tier first, then the
|
|
520
604
|
// unclassified tier, then advisory. The advisory row never changes the count,
|
|
@@ -536,23 +620,38 @@ export interface SurvivorPair {
|
|
|
536
620
|
export function pairBlockingSurvivors(
|
|
537
621
|
survivors: readonly GateSurvivor[],
|
|
538
622
|
rows: readonly { tier: RecoveredTier; locs: readonly string[] }[],
|
|
623
|
+
): SurvivorPair[] {
|
|
624
|
+
return pairInto(survivors, rows, new Set<number>(), (survivor) =>
|
|
625
|
+
survivor.tier === "blocking" ? PAIR_PREFERENCE : null,
|
|
626
|
+
);
|
|
627
|
+
}
|
|
628
|
+
|
|
629
|
+
// Pairs each survivor that `preferenceOf` admits with the first row, in its
|
|
630
|
+
// preference order, that is not in `paired`, that `rowAllowed` admits, and
|
|
631
|
+
// whose identity matches. Adds every row it takes to `paired`.
|
|
632
|
+
function pairInto(
|
|
633
|
+
survivors: readonly GateSurvivor[],
|
|
634
|
+
rows: readonly { tier: RecoveredTier; locs: readonly string[] }[],
|
|
635
|
+
paired: Set<number>,
|
|
636
|
+
preferenceOf: (survivor: GateSurvivor) => readonly RecoveredTier[] | null,
|
|
637
|
+
rowAllowed: (row: number) => boolean = () => true,
|
|
539
638
|
): SurvivorPair[] {
|
|
540
639
|
const identities = rows.map((row) => identityFromLocs(row.locs));
|
|
541
|
-
const paired = new Set<number>();
|
|
542
640
|
const pairs: SurvivorPair[] = [];
|
|
543
641
|
survivors.forEach((survivor, s) => {
|
|
544
|
-
|
|
545
|
-
if (
|
|
642
|
+
const preference = preferenceOf(survivor);
|
|
643
|
+
if (preference === null) return;
|
|
546
644
|
const survivorIdentity = identityFromFinding({
|
|
547
645
|
path: survivor.path,
|
|
548
646
|
line: survivor.line,
|
|
549
647
|
proof_refs: survivor.proof_refs,
|
|
550
648
|
});
|
|
551
|
-
for (const tier of
|
|
649
|
+
for (const tier of preference) {
|
|
552
650
|
const pick = rows.findIndex(
|
|
553
651
|
(row, i) =>
|
|
554
652
|
!paired.has(i) &&
|
|
555
653
|
row.tier === tier &&
|
|
654
|
+
rowAllowed(i) &&
|
|
556
655
|
identitiesMatch(identities[i] ?? new Map(), survivorIdentity),
|
|
557
656
|
);
|
|
558
657
|
if (pick !== -1) {
|
|
@@ -565,14 +664,25 @@ export function pairBlockingSurvivors(
|
|
|
565
664
|
return pairs;
|
|
566
665
|
}
|
|
567
666
|
|
|
568
|
-
|
|
667
|
+
interface GatePairing {
|
|
668
|
+
open: GateRow[];
|
|
669
|
+
// Open rows a blocking survivor carries: counted once, by the survivor.
|
|
670
|
+
carried: Set<number>;
|
|
671
|
+
// Open blocking rows a materiality-demoted survivor released: not counted.
|
|
672
|
+
released: Set<number>;
|
|
673
|
+
}
|
|
674
|
+
|
|
675
|
+
// The count's pairing, shared by the gate count and the ids handed to the
|
|
676
|
+
// state merge (materialityReleasedIds), so the two cannot disagree.
|
|
677
|
+
//
|
|
678
|
+
// WHY blocking survivors pair first: a blocking survivor that matches both a
|
|
679
|
+
// blocking and an unrecoverable row takes the blocking one. A demoted survivor
|
|
680
|
+
// that went first could take that row, push the blocking survivor onto the
|
|
681
|
+
// unrecoverable row, and lower the count by one.
|
|
682
|
+
function gatePairing(
|
|
569
683
|
survivors: readonly GateSurvivor[],
|
|
570
684
|
rows: readonly GateRow[],
|
|
571
|
-
):
|
|
572
|
-
const blockingSurvivors = survivors.filter(
|
|
573
|
-
(survivor) => survivor.tier === "blocking",
|
|
574
|
-
).length;
|
|
575
|
-
|
|
685
|
+
): GatePairing {
|
|
576
686
|
// One entry per prior id, and verified-gone never enters the count.
|
|
577
687
|
const seen = new Set<string>();
|
|
578
688
|
const open: GateRow[] = [];
|
|
@@ -584,22 +694,78 @@ export function unresolvedBlockingCount(
|
|
|
584
694
|
seen.add(row.id);
|
|
585
695
|
open.push(row);
|
|
586
696
|
}
|
|
587
|
-
|
|
588
|
-
const
|
|
589
|
-
|
|
697
|
+
const taken = new Set<number>();
|
|
698
|
+
const carried = new Set(
|
|
699
|
+
pairInto(survivors, open, taken, (survivor) =>
|
|
700
|
+
survivor.tier === "blocking" ? PAIR_PREFERENCE : null,
|
|
701
|
+
).map((p) => p.row),
|
|
702
|
+
);
|
|
703
|
+
const released = new Set(
|
|
704
|
+
pairInto(
|
|
705
|
+
survivors,
|
|
706
|
+
open,
|
|
707
|
+
taken,
|
|
708
|
+
(survivor) => (isDemotedFromBlocking(survivor) ? ["blocking"] : null),
|
|
709
|
+
(i) => isReleasable(open[i]),
|
|
710
|
+
).map((p) => p.row),
|
|
590
711
|
);
|
|
712
|
+
return { open, carried, released };
|
|
713
|
+
}
|
|
714
|
+
|
|
715
|
+
// WHY the guard runs on the prior too: applyMaterialityVerdicts never demotes a
|
|
716
|
+
// safety-protected finding, but it reads only the survivor. The 5-line window
|
|
717
|
+
// can pair that survivor with a different, protected prior, and releasing it
|
|
718
|
+
// would turn the gate green on a finding the guard exists to keep blocking.
|
|
719
|
+
// A blank claim counts as unknown: the badge reader writes an unrecovered
|
|
720
|
+
// claim as "" (rereview/prepare.ts), and the guard cannot read safety content
|
|
721
|
+
// that is not there.
|
|
722
|
+
function isReleasable(row: GateRow | undefined): boolean {
|
|
723
|
+
const claim = row?.claim;
|
|
724
|
+
if (row === undefined || claim === undefined || claim.trim().length === 0) {
|
|
725
|
+
return false;
|
|
726
|
+
}
|
|
727
|
+
const paths = [...identityFromLocs(row.locs).keys()];
|
|
728
|
+
if (paths.length === 0) return !isSafetyProtected({ claim, path: "" });
|
|
729
|
+
return paths.every((path) => !isSafetyProtected({ claim, path }));
|
|
730
|
+
}
|
|
731
|
+
|
|
732
|
+
export function unresolvedBlockingCount(
|
|
733
|
+
survivors: readonly GateSurvivor[],
|
|
734
|
+
rows: readonly GateRow[],
|
|
735
|
+
): number {
|
|
736
|
+
const blockingSurvivors = survivors.filter(
|
|
737
|
+
(survivor) => survivor.tier === "blocking",
|
|
738
|
+
).length;
|
|
739
|
+
const { open, carried, released } = gatePairing(survivors, rows);
|
|
591
740
|
|
|
592
741
|
// WHY unrecoverable counts: fail closed, see the note above the GateRow type.
|
|
593
742
|
// Counting only "blocking" would let an unreadable tier turn the gate green.
|
|
594
743
|
let unpairedBlocking = 0;
|
|
595
744
|
for (let i = 0; i < open.length; i++) {
|
|
596
|
-
if (
|
|
745
|
+
if (carried.has(i) || released.has(i)) continue;
|
|
597
746
|
const tier = open[i]?.tier;
|
|
598
747
|
if (tier === "blocking" || tier === TIER_UNRECOVERABLE) unpairedBlocking++;
|
|
599
748
|
}
|
|
600
749
|
return blockingSurvivors + unpairedBlocking;
|
|
601
750
|
}
|
|
602
751
|
|
|
752
|
+
// The prior ids a materiality demotion released from the count above. The
|
|
753
|
+
// state merge re-tiers exactly these rows to advisory (MergeStateInput's
|
|
754
|
+
// `releasedIds`), so the state block the next run reads agrees with this
|
|
755
|
+
// run's count. WHY ids, not a second pairing in the merge: the merge sees other
|
|
756
|
+
// rows (live, not gate rows) and other survivors (posted only, after the
|
|
757
|
+
// posting floor), so pairing again there can release a different row.
|
|
758
|
+
export function materialityReleasedIds(
|
|
759
|
+
survivors: readonly GateSurvivor[],
|
|
760
|
+
rows: readonly GateRow[],
|
|
761
|
+
): string[] {
|
|
762
|
+
const { open, released } = gatePairing(survivors, rows);
|
|
763
|
+
return [...released].flatMap((i) => {
|
|
764
|
+
const row = open[i];
|
|
765
|
+
return row === undefined ? [] : [row.id];
|
|
766
|
+
});
|
|
767
|
+
}
|
|
768
|
+
|
|
603
769
|
// The state merge (S1, S2, S6, S7). Pure. The live priors of this run, plus the
|
|
604
770
|
// previous block's rows and high-water mark, plus this run's survivors, in; the
|
|
605
771
|
// rows the state block should hold out, the new high-water mark, and how many
|
|
@@ -628,6 +794,11 @@ export interface MergeStateInput {
|
|
|
628
794
|
// of the same head (a retried PATCH, a re-run of the post step) must find the
|
|
629
795
|
// rows it already wrote, or each retry appends them again with a new id.
|
|
630
796
|
previousHead?: string | null;
|
|
797
|
+
// The prior ids this run's gate count released through a materiality
|
|
798
|
+
// demotion (materialityReleasedIds). Each such blocking row is re-tiered to
|
|
799
|
+
// advisory before pairing, so the next run's count agrees with this one.
|
|
800
|
+
// Absent releases nothing: the rows stay blocking, the fail-closed side.
|
|
801
|
+
releasedIds?: readonly string[];
|
|
631
802
|
fresh: readonly FreshStateFinding[];
|
|
632
803
|
stateBudget: number;
|
|
633
804
|
}
|
|
@@ -675,6 +846,16 @@ export function mergeStateFindings(input: MergeStateInput): MergedState {
|
|
|
675
846
|
rows.push({ ...row, status: "unconfirmed" });
|
|
676
847
|
}
|
|
677
848
|
}
|
|
849
|
+
// The release lands BEFORE pairing, so the demoted survivor (advisory now)
|
|
850
|
+
// re-pairs with its re-tiered row in the advisory pass below and updates its
|
|
851
|
+
// locs and claim, instead of appending beside it. Only the tier changes here:
|
|
852
|
+
// a released row the posting floor hid keeps the rest of what it said.
|
|
853
|
+
const released = new Set(input.releasedIds ?? []);
|
|
854
|
+
for (const [i, row] of rows.entries()) {
|
|
855
|
+
if (row.tier === "blocking" && released.has(row.id)) {
|
|
856
|
+
rows[i] = { ...row, tier: "advisory" };
|
|
857
|
+
}
|
|
858
|
+
}
|
|
678
859
|
const touched = new Set<string>();
|
|
679
860
|
|
|
680
861
|
const pairs = pairBlockingSurvivors(
|
package/src/review/boundary.ts
CHANGED
|
@@ -30,7 +30,10 @@ export type BoundaryTag =
|
|
|
30
30
|
| "previous_finding"
|
|
31
31
|
| "author_reply"
|
|
32
32
|
| "comment_body"
|
|
33
|
-
| "triage_tag"
|
|
33
|
+
| "triage_tag"
|
|
34
|
+
| "pr_title"
|
|
35
|
+
| "review_comment"
|
|
36
|
+
| "code_window";
|
|
34
37
|
|
|
35
38
|
// 8 hex characters: short enough to cost nothing in a prompt, wide enough
|
|
36
39
|
// (2^32) that guessing it from inside attacker-authored content is not a
|
package/src/review/dedupe.ts
CHANGED
|
@@ -2,7 +2,8 @@
|
|
|
2
2
|
// duplicates, renumber survivors. Deterministic — same input, same output.
|
|
3
3
|
|
|
4
4
|
import type { DraftFinding } from "./drafts";
|
|
5
|
-
import type
|
|
5
|
+
import { isNotCausedByPr, type Severity } from "./findings";
|
|
6
|
+
import { isSafetyProtected } from "./materiality-gate";
|
|
6
7
|
|
|
7
8
|
// A survivor is a draft whose id has been renumbered to the canonical
|
|
8
9
|
// F001, F002, … sequence (and, for a cross-category winner, whose proof_refs
|
|
@@ -314,14 +315,53 @@ export function mergeAndDedupe(drafts: DraftFinding[]): {
|
|
|
314
315
|
// Folded survivors are new objects; winnerOf chains still point at the
|
|
315
316
|
// original winner, so renumbering has to key on that original.
|
|
316
317
|
const originalOf = new Map<DraftFinding, DraftFinding>();
|
|
318
|
+
// #457: the tier now reads causal_disposition, so a merged group must not
|
|
319
|
+
// take its winner's word for it alone. Every draft that ends in a winner, in
|
|
320
|
+
// either pass, is a witness: when the winner says the PR did not cause the
|
|
321
|
+
// defect but any merged draft says it did (introduced, worsened, activated,
|
|
322
|
+
// or unknown), the survivor keeps that draft's disposition. One hunter's
|
|
323
|
+
// "pre-existing" must not clear a defect another hunter traced to this PR.
|
|
324
|
+
const mergedInto = new Map<DraftFinding, DraftFinding[]>();
|
|
325
|
+
for (const draft of drafts) {
|
|
326
|
+
let root = draft;
|
|
327
|
+
for (let next = winnerOf.get(root); next !== undefined && next !== root; ) {
|
|
328
|
+
root = next;
|
|
329
|
+
next = winnerOf.get(root);
|
|
330
|
+
}
|
|
331
|
+
if (root === draft) continue;
|
|
332
|
+
const members = mergedInto.get(root);
|
|
333
|
+
if (members) members.push(draft);
|
|
334
|
+
else mergedInto.set(root, [draft]);
|
|
335
|
+
}
|
|
336
|
+
// The safety guard reads only the survivor's own claim and path, and the
|
|
337
|
+
// winner's wording is all a survivor keeps. When a merged draft the guard
|
|
338
|
+
// protects (auth, secrets, data loss) folds into a winner whose wording it
|
|
339
|
+
// does not protect, the group cannot vouch that the PR is innocent: the
|
|
340
|
+
// survivor's disposition becomes `unknown`, which keeps it blocking. Never
|
|
341
|
+
// `introduced`, which no hunter said.
|
|
342
|
+
const blamingDisposition = (winner: DraftFinding) => {
|
|
343
|
+
if (!isNotCausedByPr(winner.causal_disposition)) return undefined;
|
|
344
|
+
const members = mergedInto.get(winner) ?? [];
|
|
345
|
+
const blamer = members.find(
|
|
346
|
+
(member) => !isNotCausedByPr(member.causal_disposition),
|
|
347
|
+
);
|
|
348
|
+
if (blamer !== undefined) return blamer.causal_disposition;
|
|
349
|
+
const lostSafety =
|
|
350
|
+
!isSafetyProtected(winner) &&
|
|
351
|
+
members.some((member) => isSafetyProtected(member));
|
|
352
|
+
return lostSafety ? ("unknown" as const) : undefined;
|
|
353
|
+
};
|
|
317
354
|
for (const draft of pass1) {
|
|
318
355
|
const winner = clusterWinnerOf.get(draft) as DraftFinding;
|
|
319
356
|
if (emittedWinners.has(winner)) continue;
|
|
320
357
|
emittedWinners.add(winner);
|
|
321
358
|
const losers = foldedInto.get(winner) as DraftFinding[];
|
|
359
|
+
const blame = blamingDisposition(winner);
|
|
322
360
|
if (losers.length === 0) {
|
|
323
|
-
|
|
324
|
-
|
|
361
|
+
const survivor =
|
|
362
|
+
blame === undefined ? winner : { ...winner, causal_disposition: blame };
|
|
363
|
+
survivorsRaw.push(survivor);
|
|
364
|
+
originalOf.set(survivor, winner);
|
|
325
365
|
continue;
|
|
326
366
|
}
|
|
327
367
|
const foldedRefs = [...winner.proof_refs];
|
|
@@ -330,7 +370,11 @@ export function mergeAndDedupe(drafts: DraftFinding[]): {
|
|
|
330
370
|
if (!foldedRefs.includes(ref)) foldedRefs.push(ref);
|
|
331
371
|
}
|
|
332
372
|
}
|
|
333
|
-
const folded = {
|
|
373
|
+
const folded = {
|
|
374
|
+
...winner,
|
|
375
|
+
proof_refs: foldedRefs,
|
|
376
|
+
...(blame === undefined ? {} : { causal_disposition: blame }),
|
|
377
|
+
};
|
|
334
378
|
survivorsRaw.push(folded);
|
|
335
379
|
originalOf.set(folded, winner);
|
|
336
380
|
}
|
package/src/review/findings.ts
CHANGED
|
@@ -5,6 +5,7 @@
|
|
|
5
5
|
// validates the assembled output and merges in the driver-owned run envelope
|
|
6
6
|
// (schema_version, telemetry) before anything is written to a run dir.
|
|
7
7
|
|
|
8
|
+
import { isSafetyProtected } from "./materiality-gate";
|
|
8
9
|
import type { RootCauseSummary } from "./root-cause";
|
|
9
10
|
|
|
10
11
|
export const SCHEMA_VERSION = "1.0.0";
|
|
@@ -82,6 +83,11 @@ export interface Finding {
|
|
|
82
83
|
// this field still validates against the unchanged 1.0.0 schema on the lab
|
|
83
84
|
// side and a document without it still validates here. No version bump.
|
|
84
85
|
root_cause_id?: string;
|
|
86
|
+
// The materiality gate's verdict, present only on a finding it demoted from
|
|
87
|
+
// blocking to advisory. ADDITIVE and OPTIONAL, same precedent as
|
|
88
|
+
// `root_cause_id`: both validators are allowlists that never reject unknown
|
|
89
|
+
// keys, so the schema stays 1.0.0 and a document without it still validates.
|
|
90
|
+
materiality?: { label: "material" | "immaterial"; reason: string };
|
|
85
91
|
}
|
|
86
92
|
|
|
87
93
|
// Refuted findings are excluded from `findings[]` (scorer contract unchanged)
|
|
@@ -587,8 +593,41 @@ export function validateFindingsDocument(candidate: unknown): FindingsDocument {
|
|
|
587
593
|
// positive `downgraded-latent` verdict, and also when an EXPECTED refuter
|
|
588
594
|
// check was cut short before the finding was ever submitted (see the
|
|
589
595
|
// `refuterCutShort` option below).
|
|
596
|
+
// #457: the two dispositions that say "not this PR". `worsened` and
|
|
597
|
+
// `behavior-activated` are the PR's doing, and `unknown` causality is not
|
|
598
|
+
// evidence of innocence.
|
|
599
|
+
export function isNotCausedByPr(
|
|
600
|
+
disposition: CausalDisposition | undefined,
|
|
601
|
+
): boolean {
|
|
602
|
+
return disposition === "pre-existing" || disposition === "base-only";
|
|
603
|
+
}
|
|
604
|
+
|
|
605
|
+
// Whether the causal rule takes a finding out of the blocking tier. The label is
|
|
606
|
+
// the hunter's own, never checked against the diff, so the materiality gate's
|
|
607
|
+
// safety guard applies here too: a finding about auth, secrets, isolation or
|
|
608
|
+
// data loss keeps blocking whatever disposition it carries, because a false
|
|
609
|
+
// "pre-existing" there would clear a required check on exactly the class the
|
|
610
|
+
// guard exists to keep red. Shared by deriveTier, the re-review release
|
|
611
|
+
// (rereview/state.ts) and the inline comment's explanation (review/report.ts).
|
|
612
|
+
export function isCausallyExempt(
|
|
613
|
+
finding: Pick<Finding, "causal_disposition" | "claim" | "path">,
|
|
614
|
+
): boolean {
|
|
615
|
+
return (
|
|
616
|
+
isNotCausedByPr(finding.causal_disposition) &&
|
|
617
|
+
!isSafetyProtected({ claim: finding.claim, path: finding.path })
|
|
618
|
+
);
|
|
619
|
+
}
|
|
620
|
+
|
|
590
621
|
export function deriveTier(
|
|
591
|
-
finding: Pick<
|
|
622
|
+
finding: Pick<
|
|
623
|
+
Finding,
|
|
624
|
+
| "severity"
|
|
625
|
+
| "evidence_class"
|
|
626
|
+
| "refuter_verdict"
|
|
627
|
+
| "causal_disposition"
|
|
628
|
+
| "claim"
|
|
629
|
+
| "path"
|
|
630
|
+
>,
|
|
592
631
|
options: {
|
|
593
632
|
// Whether a refuter check this finding was ENTITLED TO never got to
|
|
594
633
|
// submit its verdict. NOT a synonym for "the run was truncated": the
|
|
@@ -607,6 +646,13 @@ export function deriveTier(
|
|
|
607
646
|
const isBlockerClass =
|
|
608
647
|
finding.severity === "BLOCKER" || finding.severity === "CRITICAL";
|
|
609
648
|
if (!isBlockerClass) return "advisory";
|
|
649
|
+
// #457: a defect this PR did not cause never blocks this PR. The tier gates
|
|
650
|
+
// the PR, and a triage reply never lowers the blocking count (S7), so a
|
|
651
|
+
// pre-existing blocker could only be cleared by fixing code the PR does not
|
|
652
|
+
// own, or by an override; on a v0.3.0 review it held the gate red until the
|
|
653
|
+
// PR merged over it. isCausallyExempt says which dispositions count, and why a
|
|
654
|
+
// safety-protected finding is never exempt.
|
|
655
|
+
if (isCausallyExempt(finding)) return "advisory";
|
|
610
656
|
if (finding.evidence_class === "insufficient") return "advisory";
|
|
611
657
|
// Ordered BEFORE the deterministic short-circuit on purpose. A verdict that
|
|
612
658
|
// could not outrank `deterministic` would be inert exactly where it is
|
|
@@ -0,0 +1,134 @@
|
|
|
1
|
+
// The materiality gate's PURE half (odd/tasks/materiality-gate.md S3, S4,
|
|
2
|
+
// S12): the safety guard, the judge's input window and prompt, and the
|
|
3
|
+
// verdict→demotion map. The impure half (spawning the judge) lives in the
|
|
4
|
+
// pipeline; the judge's instructions are `prompts/materiality.md`.
|
|
5
|
+
|
|
6
|
+
import { type MaterialityVerdict, normalizeClaim } from "#compare/materiality";
|
|
7
|
+
import { blockForgesNonce, wrapBlock } from "#review/boundary";
|
|
8
|
+
import type { Tier } from "#review/findings";
|
|
9
|
+
import { redactEvidenceText } from "../security/evidence-redaction";
|
|
10
|
+
|
|
11
|
+
// Deterministic carve-out from the posting policy: a finding that touches
|
|
12
|
+
// security, credentials, isolation or data integrity is never sent to the
|
|
13
|
+
// judge and never demoted, whatever a model would say. It over-protects on
|
|
14
|
+
// purpose (an "argv token" matches `token\w*`): a false positive costs one
|
|
15
|
+
// finding staying blocking, a false negative hides a real exposure. Extended
|
|
16
|
+
// for the two misses the offline exam surfaced: a lost-update race that
|
|
17
|
+
// silently drops a user's edit, and hard deletes.
|
|
18
|
+
export const SAFETY_PATTERN =
|
|
19
|
+
/\b(auth\w*|credential\w*|secret\w*|passw\w*|token\w*|api[ _-]?key\w*|permission\w*|privilege\w*|access[ -]control|sandbox\w*|symlink\w*|isolation|escap\w+ (the )?(sandbox|worktree)|inject\w*|xss|csrf|ssrf|rce|traversal|sanitiz\w*|encrypt\w*|decrypt\w*|signature\w*|verif\w+ (the )?signature|data loss|lose[sd]? (the )?(data|rows|records|findings|audit)|corrupt\w*|overwrit\w+|delet\w+ (the )?(user|data|rows|records|cache)|leak\w* (the )?(secret|token|credential|key)|lost[ -]update\w*|los[et]s? (the )?(user'?s? |concurrent |other )?(edit|update|write|change)s?|silently (drop|discard|overwrit|delet|lost)\w*|(is|are|gets?) (silently )?lost|hard[- ]delet\w*|(race|concurren\w*)[^.]{0,80}(overwrit|delet|hard-delet|clobber|drop)\w*)\b/i;
|
|
20
|
+
|
|
21
|
+
export function isSafetyProtected(f: { claim: string; path: string }): boolean {
|
|
22
|
+
return SAFETY_PATTERN.test(f.claim) || SAFETY_PATTERN.test(f.path);
|
|
23
|
+
}
|
|
24
|
+
|
|
25
|
+
export const MATERIALITY_WINDOW_LINES = 25;
|
|
26
|
+
|
|
27
|
+
// The finding's line ±25 at the reviewed head, 1-based, the finding line
|
|
28
|
+
// marked with ">". A trailing newline does not count as an extra empty line.
|
|
29
|
+
export function codeWindow(fileText: string, line: number): string {
|
|
30
|
+
const lines = fileText.split("\n");
|
|
31
|
+
if (lines.length > 1 && lines.at(-1) === "") lines.pop();
|
|
32
|
+
const first = Math.max(1, line - MATERIALITY_WINDOW_LINES);
|
|
33
|
+
const last = Math.min(lines.length, line + MATERIALITY_WINDOW_LINES);
|
|
34
|
+
const out: string[] = [];
|
|
35
|
+
for (let n = first; n <= last; n++) {
|
|
36
|
+
out.push(`${n}${n === line ? ">" : " "} ${lines[n - 1]}`);
|
|
37
|
+
}
|
|
38
|
+
return redactEvidenceText(out.join("\n"));
|
|
39
|
+
}
|
|
40
|
+
|
|
41
|
+
// The title, the claim, the path and the window are all author-controlled.
|
|
42
|
+
// The title, claim and window are wrapped with the run's boundary nonce (S12);
|
|
43
|
+
// the path stays a plain line but must carry no control character. Content that
|
|
44
|
+
// already carries the nonce returns null rather than throwing: wrapBlock's
|
|
45
|
+
// throw would kill a paid run, and the caller treats null as "cannot judge
|
|
46
|
+
// safely" and leaves the finding blocking (fail-open toward blocking, S6).
|
|
47
|
+
// The check runs on the exact strings handed to wrapBlock, so it never throws.
|
|
48
|
+
export function renderMaterialityPrompt(
|
|
49
|
+
input: {
|
|
50
|
+
prTitle: string;
|
|
51
|
+
claim: string;
|
|
52
|
+
path: string;
|
|
53
|
+
window: string | null;
|
|
54
|
+
},
|
|
55
|
+
nonce: string,
|
|
56
|
+
): string | null {
|
|
57
|
+
const title = input.prTitle.replace(/\s+/g, " ").trim();
|
|
58
|
+
const claim = normalizeClaim(redactEvidenceText(input.claim));
|
|
59
|
+
// The path is the one author-controlled string outside a nonced block. A
|
|
60
|
+
// control character (a newline above all) would let it open a fresh line
|
|
61
|
+
// that reads as an instruction, so such a path cannot be judged safely.
|
|
62
|
+
// biome-ignore lint/suspicious/noControlCharactersInRegex: detecting them is the point
|
|
63
|
+
if (/[\u0000-\u001f\u007f]/.test(input.path)) return null;
|
|
64
|
+
const filePath = input.path.replace(/\s+/g, " ").trim();
|
|
65
|
+
const window = input.window ?? "";
|
|
66
|
+
if (
|
|
67
|
+
[title, claim, filePath, window].some((part) =>
|
|
68
|
+
blockForgesNonce(part, nonce),
|
|
69
|
+
)
|
|
70
|
+
) {
|
|
71
|
+
return null;
|
|
72
|
+
}
|
|
73
|
+
const parts = [
|
|
74
|
+
"Pull request title:",
|
|
75
|
+
wrapBlock("pr_title", nonce, title),
|
|
76
|
+
"",
|
|
77
|
+
"Review comment:",
|
|
78
|
+
wrapBlock("review_comment", nonce, claim),
|
|
79
|
+
"",
|
|
80
|
+
`File: ${filePath}`,
|
|
81
|
+
];
|
|
82
|
+
if (input.window !== null) {
|
|
83
|
+
parts.push("", "Code:", wrapBlock("code_window", nonce, window));
|
|
84
|
+
}
|
|
85
|
+
return parts.join("\n");
|
|
86
|
+
}
|
|
87
|
+
|
|
88
|
+
// `protectedIds` carries protection the finding's own text no longer shows:
|
|
89
|
+
// consolidation can fold a protected finding into a primary whose merged claim
|
|
90
|
+
// and path read benign, and the guard must follow the defect, not the wording.
|
|
91
|
+
export function materialityCandidates<
|
|
92
|
+
T extends { id?: string; tier: Tier; claim: string; path: string },
|
|
93
|
+
>(
|
|
94
|
+
findings: T[],
|
|
95
|
+
protectedIds: ReadonlySet<string> = new Set(),
|
|
96
|
+
): { judge: T[]; protectedCount: number } {
|
|
97
|
+
const judge: T[] = [];
|
|
98
|
+
let protectedCount = 0;
|
|
99
|
+
for (const f of findings) {
|
|
100
|
+
if (f.tier !== "blocking") continue;
|
|
101
|
+
if (isProtected(f, protectedIds)) protectedCount++;
|
|
102
|
+
else judge.push(f);
|
|
103
|
+
}
|
|
104
|
+
return { judge, protectedCount };
|
|
105
|
+
}
|
|
106
|
+
|
|
107
|
+
function isProtected(
|
|
108
|
+
f: { id?: string; claim: string; path: string },
|
|
109
|
+
protectedIds: ReadonlySet<string>,
|
|
110
|
+
): boolean {
|
|
111
|
+
return isSafetyProtected(f) || (f.id !== undefined && protectedIds.has(f.id));
|
|
112
|
+
}
|
|
113
|
+
|
|
114
|
+
// The guard is re-checked here, not only in materialityCandidates: a verdict
|
|
115
|
+
// that reaches this map for a protected finding must still never demote it.
|
|
116
|
+
export function applyMaterialityVerdicts<
|
|
117
|
+
T extends { id: string; tier: Tier; claim: string; path: string },
|
|
118
|
+
>(
|
|
119
|
+
findings: T[],
|
|
120
|
+
verdicts: Map<string, MaterialityVerdict>,
|
|
121
|
+
protectedIds: ReadonlySet<string> = new Set(),
|
|
122
|
+
): (T & { materiality?: MaterialityVerdict })[] {
|
|
123
|
+
return findings.map((f) => {
|
|
124
|
+
const verdict = verdicts.get(f.id);
|
|
125
|
+
if (
|
|
126
|
+
f.tier !== "blocking" ||
|
|
127
|
+
verdict?.label !== "immaterial" ||
|
|
128
|
+
isProtected(f, protectedIds)
|
|
129
|
+
) {
|
|
130
|
+
return f;
|
|
131
|
+
}
|
|
132
|
+
return { ...f, tier: "advisory" as const, materiality: verdict };
|
|
133
|
+
});
|
|
134
|
+
}
|