Skip to content

test(sccm): prepare correlation safety contracts - #385

Merged
adamgell merged 18 commits into
codex/parser-family-skeletonfrom
codex/sccm-333-correlation-contracts
Jul 31, 2026
Merged

adamgell merged 18 commits into
codex/parser-family-skeletonfrom
codex/sccm-333-correlation-contracts

Conversation

@adamgell

Copy link
Copy Markdown
Owner

Tracks #333 and epic #317.

Scope

  • add a non-executable pair registry for policy↔MP, content↔DP, and a Candidate-only future updates↔SUP entry
  • add 13 shared false-causality guards
  • instantiate all 13 guards independently across 14 policy↔MP and 14 content↔DP adversarial scenarios
  • cover client-only, server-only, same-time/no-key, conflicting key, topology mismatch, profile/content-version mismatch, invalid offset, partial capture, rotation split, unrelated terminal error, redaction, and reordered input
  • validate merged repo: fixture references while preserving pending SCCM Server: diagnose distribution-point and content-distribution workflows #329 scenarios as explicit issue:#329: references
  • document exact upstream blockers and evidence classification

This PR is fixture/test preparation only. It deliberately adds no production correlation module, shared SCCM model change, public API, reducer, graph, native code, live query, or causal finding. A test fails if src/sccm/correlation appears in this slice. Every pair is non-executable and every adversarial scenario forbids High-confidence cause and ExactCorroborated output.

Test-first evidence

RED: cargo test --locked -p cmtraceopen-parser --test sccm_correlation_contract ran 6 tests: the no-production guard passed, while 5/5 fixture/registry targets failed because the matrices did not exist.

GREEN:

  • cargo test --locked -p cmtraceopen-parser --test sccm_correlation_contract — 6/6
  • cargo test --locked -p cmtraceopen-parser --test sccm_spine_contract — 61/61
  • cargo test --locked -p cmtraceopen-parser --test sccm_client_deployment_fixture_contract — 8/8
  • cargo test --locked -p cmtraceopen-parser --test sccm_server_intake_fixture_contract — 1/1
  • cargo test --locked -p cmtraceopen-parser — pass
  • cargo clippy --locked -p cmtraceopen-parser --all-targets -- -D warnings — pass
  • cargo check --locked -p cmtraceopen-parser --target wasm32-unknown-unknown — pass
  • npx tsc --noEmit — pass
  • Rust 1.88 scoped rustfmt, all added JSON through jq empty, and git diff --check — pass

cargo +1.88.0 fmt --check --all remains red only on the pre-existing unrelated 17-file formatting baseline; the #333 Rust file is formatted and absent from that diff.

Dependency/review gates

@coderabbitai

coderabbitai Bot commented Jul 31, 2026 •

Copy link
Copy Markdown

Important

Review skipped

Auto reviews are disabled on base/target branches other than the default branch.

Please check the settings in the CodeRabbit UI or the .coderabbit.yaml file in this repository. To trigger a single review, invoke the @coderabbitai review command.

⚙️ Run configuration

Configuration used: Organization UI

Review profile: CHILL

Plan: Pro Plus

Run ID: 55435380-b41d-4040-b994-6d49f68d8a88

You can disable this status message by setting the reviews.review_status to false in the CodeRabbit configuration file.

Use the checkbox below for a quick retry:

  • 🔍 Trigger review

Comment @coderabbitai help to get the list of available commands.

@adamgell

Copy link
Copy Markdown
Owner Author

@coderabbitai review

Please perform a substantive exact-head review of cd9ac101919a9d2525c2678b1dc062472b1b2704. Focus on false-causality completeness, exact per-pair coverage of every shared guard, fail-closed ceilings, non-executable registry state, pending-upstream reference honesty, privacy markers/public projections, deterministic reorder contracts, and the explicit absence of production correlation code.

@coderabbitai

coderabbitai Bot commented Jul 31, 2026 •

Copy link
Copy Markdown
🧩 Analysis chain

🏁 Script executed:

#!/bin/bash
set -euo pipefail

head='cd9ac101919a9d2525c2678b1dc062472b1b2704'
parent="$(git rev-parse "${head}^")"

echo '== Exact commit =='
git show -s --format='commit=%H%nparent=%P%nsubject=%s%n%n%b' "$head"

echo '== Changed files and summary =='
git diff --stat "$parent" "$head"
git diff --name-status "$parent" "$head"

echo '== Changed paths containing correlation-related terms =='
git diff --name-only "$parent" "$head" | rg -n -i 'sccm|correlation|fixture|contract|registry|guard' || true

echo '== Contract and fixture file map =='
fd -t f . | rg -n 'sccm.*(correlation|contract)|correlation.*sccm|sccm.*\.(json|rs)$' || true

echo '== Source-path checks for production correlation module =='
fd -t d correlation src 2>/dev/null || true
rg -n --hidden --glob '!target/**' --glob '!node_modules/**' \
  'src/sccm/correlation|mod\s+correlation\b|pub\s+mod\s+correlation\b|sccm::correlation' . || true

echo '== AST outlines for changed Rust files =='
while IFS= read -r file; do
  case "$file" in
    *.rs)
      echo "--- $file"
      ast-grep outline "$file" --items all || true
      ;;
  esac
done < <(git diff --name-only "$parent" "$head")

echo '== Full exact diff =='
git diff --no-ext-diff --unified=80 "$parent" "$head"

Length of output: 18826


🏁 Script executed:

#!/bin/bash
set -euo pipefail

head='cd9ac101919a9d2525c2678b1dc062472b1b2704'
tmp="$(mktemp -d)"
trap 'rm -rf "$tmp"' EXIT

paths=(
  'crates/cmtraceopen-parser/tests/fixtures/sccm/correlation/README.md'
  'crates/cmtraceopen-parser/tests/fixtures/sccm/correlation/pair-registry.json'
  'crates/cmtraceopen-parser/tests/fixtures/sccm/correlation/shared/adversarial-matrix.json'
  'crates/cmtraceopen-parser/tests/fixtures/sccm/correlation/policy_management_point/adversarial-matrix.json'
  'crates/cmtraceopen-parser/tests/fixtures/sccm/correlation/content_distribution_point/adversarial-matrix.json'
  'crates/cmtraceopen-parser/tests/sccm_correlation_contract.rs'
  'docs/sccm/preparation/issue-333-correlation-contracts.md'
)

for path in "${paths[@]}"; do
  mkdir -p "$tmp/$(dirname "$path")"
  git show "${head}:${path}" > "$tmp/$path"
done

echo '== JSON top-level keys and cardinalities =='
TMPDIR_REVIEW="$tmp" python3 - <<'PY'
import json
import os
from pathlib import Path

root = Path(os.environ["TMPDIR_REVIEW"]) / "crates/cmtraceopen-parser/tests/fixtures/sccm/correlation"
for path in sorted(root.rglob("*.json")):
    value = json.loads(path.read_text())
    print(f"\n--- {path.relative_to(root)}")
    if isinstance(value, dict):
        print("top-level:", ", ".join(value.keys()))
        for key, item in value.items():
            if isinstance(item, list):
                print(f"{key}: list[{len(item)}]")
            elif isinstance(item, dict):
                print(f"{key}: object keys={list(item.keys())}")
            else:
                print(f"{key}: {item!r}")
PY

echo '== Scenario field inventory and coverage checks =='
TMPDIR_REVIEW="$tmp" python3 - <<'PY'
import json
import os
from collections import Counter
from pathlib import Path

root = Path(os.environ["TMPDIR_REVIEW"]) / "crates/cmtraceopen-parser/tests/fixtures/sccm/correlation"
for name in ("policy_management_point", "content_distribution_point", "shared"):
    path = root / name / "adversarial-matrix.json"
    data = json.loads(path.read_text())
    rows = next((v for v in data.values() if isinstance(v, list)), [])
    print(f"\n--- {name}: {len(rows)} rows")
    fields = Counter(k for row in rows if isinstance(row, dict) for k in row)
    print("fields:", dict(sorted(fields.items())))
    for index, row in enumerate(rows, 1):
        if not isinstance(row, dict):
            print(f"row {index}: non-object {row!r}")
            continue
        compact = {k: row.get(k) for k in (
            "id", "scenario_id", "guard_id", "shared_guard_id", "pair",
            "expected_max_confidence", "max_confidence", "expected_cause",
            "expected_output", "fixture_refs", "references", "privacy",
            "public_projection", "reorder"
        ) if k in row}
        print(f"row {index}: {json.dumps(compact, sort_keys=True)}")
PY

echo '== Pair registry =='
cat -n "$tmp/crates/cmtraceopen-parser/tests/fixtures/sccm/correlation/pair-registry.json"

echo '== Shared guard matrix =='
cat -n "$tmp/crates/cmtraceopen-parser/tests/fixtures/sccm/correlation/shared/adversarial-matrix.json"

echo '== Rust contract test =='
cat -n "$tmp/crates/cmtraceopen-parser/tests/sccm_correlation_contract.rs"

echo '== Fixture README =='
cat -n "$tmp/crates/cmtraceopen-parser/tests/fixtures/sccm/correlation/README.md"

echo '== Preparation document =='
cat -n "$tmp/docs/sccm/preparation/issue-333-correlation-contracts.md"

echo '== Exact SCCM source tree and exact path references =='
git ls-tree -r --name-only "$head" -- crates/cmtraceopen-parser/src/sccm \
  | rg -n '(^|/)correlation(/|$)' || true
git grep -n -E 'src/sccm/correlation|sccm::correlation|mod[[:space:]]+correlation|pub[[:space:]]+mod[[:space:]]+correlation' "$head" -- crates/cmtraceopen-parser \
  || true

Length of output: 43827


🏁 Script executed:

#!/bin/bash
set -euo pipefail

head='cd9ac101919a9d2525c2678b1dc062472b1b2704'
tmp="$(mktemp -d)"
trap 'rm -rf "$tmp"' EXIT

for path in \
  crates/cmtraceopen-parser/tests/fixtures/sccm/correlation/pair-registry.json \
  crates/cmtraceopen-parser/tests/fixtures/sccm/correlation/shared/adversarial-matrix.json \
  crates/cmtraceopen-parser/tests/fixtures/sccm/correlation/policy_management_point/adversarial-matrix.json \
  crates/cmtraceopen-parser/tests/fixtures/sccm/correlation/content_distribution_point/adversarial-matrix.json
do
  mkdir -p "$tmp/$(dirname "$path")"
  git show "${head}:${path}" > "$tmp/$path"
done

TMPDIR_REVIEW="$tmp" HEAD_REVIEW="$head" python3 - <<'PY'
import json
import os
import subprocess
from collections import Counter, defaultdict
from pathlib import Path

tmp = Path(os.environ["TMPDIR_REVIEW"])
head = os.environ["HEAD_REVIEW"]
root = tmp / "crates/cmtraceopen-parser/tests/fixtures/sccm/correlation"
shared = json.loads((root / "shared/adversarial-matrix.json").read_text())
guards = {item["guardId"]: item for item in shared["guards"]}

print("== Per-pair scenario mapping ==")
for directory in ("policy_management_point", "content_distribution_point"):
    matrix = json.loads((root / directory / "adversarial-matrix.json").read_text())
    print(f"\n--- {directory} ({matrix['workflow']})")
    seen = Counter()
    for s in matrix["scenarios"]:
        seen.update(s["guardIds"])
        expected = s["expected"]
        print(
            f"{s['scenarioId']}: guards={s['guardIds']}; "
            f"ceiling={expected['linkStrengthCeiling']}/{expected['confidenceCeiling']}; "
            f"reasons={expected['reasonCodes']}; requests={expected['artifactRequests']}; "
            f"refs=({s['clientFixtureRef']!r}, {s['serverFixtureRef']!r}); "
            f"markers={s['privateInputMarkers']!r}; "
            f"projection={json.dumps(s['expectedPublicProjection'], sort_keys=True)}"
        )
    print("guard counts:", dict(sorted(seen.items())))
    print("missing guard IDs:", sorted(set(guards) - set(seen)))
    print("repeated guard IDs:", {k:v for k,v in sorted(seen.items()) if v != 1})

print("\n== Required-output representation check ==")
for directory in ("policy_management_point", "content_distribution_point"):
    matrix = json.loads((root / directory / "adversarial-matrix.json").read_text())
    by_guard = defaultdict(list)
    for s in matrix["scenarios"]:
        for gid in s["guardIds"]:
            by_guard[gid].append(s)
    print(f"\n--- {directory}")
    for gid, contract in guards.items():
        scenarios = by_guard[gid]
        values = []
        for s in scenarios:
            combined = {
                "expected": s["expected"],
                "expectedPublicProjection": s["expectedPublicProjection"],
            }
            encoded = json.dumps(combined, sort_keys=True)
            values.append(all(output in encoded for output in contract["requiredOutputs"]))
        print(f"{gid}: required={contract['requiredOutputs']}; represented={values}")

print("\n== Fixture reference forms and exact repository directory checks ==")
for directory in ("policy_management_point", "content_distribution_point"):
    matrix = json.loads((root / directory / "adversarial-matrix.json").read_text())
    print(f"\n--- {directory}")
    for s in matrix["scenarios"]:
        for side in ("client", "server"):
            ref = s[f"{side}FixtureRef"]
            status = "non-repo"
            if ref.startswith("repo:"):
                target = ref[5:]
                result = subprocess.run(
                    ["git", "cat-file", "-e", f"{head}:{target}"],
                    stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True
                )
                status = f"repo-path-exists={result.returncode == 0}"
            print(f"{s['scenarioId']} {side}: {ref} [{status}]")
PY

echo '== Exact matrix line locations for potential findings =='
git show "${head}:crates/cmtraceopen-parser/tests/sccm_correlation_contract.rs" \
  | nl -ba \
  | sed -n '276,490p'

Length of output: 25599


@adamgell, I reviewed exact commit cd9ac101919a9d2525c2678b1dc062472b1b2704.

I found two contract gaps.

  1. P2 — The shared requiredOutputs do not constrain either pair matrix.
    Line 440 checks only that each guard has a nonempty, sorted requiredOutputs list. assert_matrix_contract() checks guard-ID coverage, ceilings, and private-marker absence, but it does not map a guard’s required outputs to fields in expected or expectedPublicProjection. For example, sourceLocalResults, incompatibilityReason, and unlinkedTerminalEvidence can be removed from a scenario projection without failing this suite. This makes the shared output list documentation instead of an enforced false-causality contract.

    Define typed expected-output fields, or add an explicit guard-to-projection predicate. Assert it for every scenario that declares that guard.

  2. P2 — The reordered-input fixtures do not encode different input orders.
    Line 472 compares two expected results, but ScenarioContract has no ordered-input or input-order field. The A and B scenarios use the same fixture references and the test can only prove that two declared outputs are equal. It cannot prove that the inputs are reordered or that serialization remains deterministic after reordering.

    Add a typed ordered input manifest or an explicit sequence field. Require the A and B cases to contain the same inputs in opposite orders. Then compare the normalized serialized result and deterministic result ID.

The remaining requested areas are covered by the exact head:

  • Both executable pair matrices include all 13 shared guards.
  • All adversarial cases forbid High confidence and exactCorroborated.
  • pair-registry.json remains non-executable. The updates↔SUP pair remains candidate.
  • All checked repo: references resolve at the exact commit.
  • Pending DP references use issue:SCCM Server: diagnose distribution-point and content-distribution workflows #329:.
  • Private markers do not appear in the declared public projections.
  • No crates/cmtraceopen-parser/src/sccm/correlation module exists in this commit.
✅ Action performed

Review finished.

Note: CodeRabbit is an incremental review system and does not re-review already reviewed commits. This command is applicable only when automatic reviews are paused.

@adamgell adamgell left a comment

Copy link
Copy Markdown
Owner Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

BLOCK — exact-head independent review of cd9ac101919a9d2525c2678b1dc062472b1b2704.

The slice is correctly preparation-only: the seven changed paths are tests/fixtures/docs, no production SCCM correlation/shared-model/reducer/native/live code exists, both pair matrices list all 13 guards, every adversarial expected ceiling forbids High/ExactCorroborated, registry production/RuleValidated/module flags are off, and updates↔SUP remains Candidate. Hard mutations of those ceilings/flags, missing or unknown guard IDs, and empty client/server counterpart requests were rejected.

Acceptance is BLOCKED by fail-open contract mutations:

  1. Guard declarations are not bound back to their adversarial inputs. Neutralizing the key/conflict/topology/version/profile/offset/rotation/coverage/terminal state while leaving the guard label kept the focused suite 6/6 green.
  2. The privacy assertion misses a decoded LAB\SyntheticUser leak because it searches serialized escaped JSON; an undeclared raw C:\Windows\CCM\Logs path also passes.
  3. requiredOutputs are not enforced against expected outputs/projections.
  4. Reorder A/B contains no ordered input sequence and accepts different inputs.
  5. Pending #329 reference honesty and exact pair issue ownership are not enforced; an unrelated client fixture can replace an issue:#329: server ref, and the content pair server issue can be rewritten to #328.

Hosted CodeRabbit independently corroborated the required-output and reorder gaps: #385 (comment). The local CodeRabbit CLI was also invoked at this exact head but was rate-limited, so it is not an additional approval.

Fresh verification: focused 6/6; spine 61/61; deployment 8/8; server intake 1/1; full parser pass; strict Clippy pass; wasm32 pass; TypeScript pass; four JSON files valid; scoped Rustfmt and diff checks pass; remote exactness passes. Repository-wide Rustfmt remains red on exactly the same 24-file pre-existing base/head set (zero head-only paths). Keep draft/open; fix test-first and request a new exact-head independent plus substantive CodeRabbit review.

@adamgell adamgell added test Testing related sccm SCCM/ConfigMgr related parser Log parser related enhancement New feature or request labels Jul 31, 2026
adamgell added 17 commits July 31, 2026 16:31
Convert the panic-based matrix, guard, and registry assertions
into Result-returning validators so adversarial mutation probes
can assert rejection without process aborts. Behavior-preserving:
the six existing contract tests still pass unchanged.

Refs #333
Add mutation probes proving the redaction contract inspects only
serialized JSON bytes: a decoded LAB backslash marker value, an
undeclared raw Windows log path, and a marker hidden in a
projection key all pass because serde escaping defeats the byte
containment check. Fails until the projection walk is decoded.

Refs #333
Walk the expected public projection as a decoded JSON value tree:
every object key and string value must fit a closed public grammar
(ascii alphanumerics, dash, dot, max 96 bytes) and no decoded
string may contain a declared private marker. Escaped backslash
identities, raw Windows paths, and marker-shaped keys now fail.

Refs #333
Add mutation probes proving fixture refs are unconditional: the
pending #329 server side accepts a merged client repo dir or a
synthetic ref, a policy server slot accepts a client-side repo
dir or a pending issue ref, and the registry accepts a rewritten
content server issue or a dropped #329 acceptance blocker.

Refs #333
Give each pair side an explicit corpus state: merged sides must
cite repo dirs under their own side prefix or synthetic inputs,
while the pending #329 content server side may only use
issue:#329 refs or absent. Pin registry pair ownership (#322 to
#329, #321 to #328, #323 to #330) and keep the #329 pending
acceptance blocker declared.

Refs #333
Add the review's mutation set: every guard label survives with
its adversarial input neutralized (missing to exact, conflicting
to exact, incompatible to compatible, mismatch and unknown to
validated, invalid offset to usable, split to complete, partial
to complete, unrelated to corroborating) and an absent server
ref survives a complete-coverage claim. All must fail closed.

Refs #333
Bind guard labels to input state in both directions: each of the
thirteen guards has an exact demonstration predicate over the
scenario inputs, a declared guard whose inputs were neutralized
is rejected, a demonstrated guard that is undeclared is rejected,
and absent fixture refs must agree with one-sided coverage.

Refs #333
Require the A/B reordered scenarios to carry an ordered input
evidence manifest: same multiset, B replaying A in opposite
order, both sides present, identical fixture refs and input
state, and one deterministic serialization and result id. Fails
because the scenarios encode no reordered inputs at all.

Refs #333
Give each reordered A/B scenario an orderedInputEvidence
manifest of synthetic client and server evidence tokens, with B
replaying A's multiset in opposite order, and admit the field in
the typed scenario contract.

Refs #333
Add mutation probes proving the validator ignores the encoded
reorder evidence: B replaying A's order unchanged, a divergent B
client fixture ref, an emptied A manifest under a declared
reordered-input guard, and an untagged evidence token all pass.

Refs #333
Demonstrate the reordered-input guard by the encoded manifest:
entries must be side-tagged synthetic tokens covering both
sides, exactly two reordered scenarios must share identical
fixture refs and input state, B must replay A's evidence in
opposite order, and both must serialize one deterministic
expected contract and public projection.

Refs #333
Add mutation probes proving requiredOutputs are decorative: an
arbitraryOutput token in the shared guard matrix, a projection
reduced to a bare notCausal outcome, and a client-only scenario
requesting no server artifact all pass the suite.

Refs #333
Pin every guard's requiredOutputs to a closed obligation
vocabulary and give each token an executable predicate over the
scenario's expected results and public projection. The shared
matrix rejects unknown tokens and every declared guard's
obligations are asserted against its scenario contract.

Refs #333
Keep the correlation fixture README honest about the hardened
contract: guard demonstration, executable output obligations,
side-bound fixture refs, the #329 pending-only server side, and
the opposite-order evidence manifests.

Refs #333
The marker/guard coupling is now enforced by the redaction
boundary demonstration biconditional, and clippy rejects the
leftover double-negated form.

Refs #333
The skeleton merge landed the #329 DP preparation corpus (PR
374), so 'without pretending they exist on the program baseline'
no longer described reality. The Pending state itself is still
correct: the corpus is merged, but the #329 public fact
interface is not independently accepted and no production
reducer exists for the #322/#329 pair, so the content server
side stays issue-marked and the registry blocker stands.

Refs #333
@adamgell

Copy link
Copy Markdown
Owner Author

@coderabbitai full review

@adamgell adamgell left a comment

Copy link
Copy Markdown
Owner Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Round-2 adversarial review of PR #385 at exact head cc7d2b5.

Verdict: PASS (approve). All five round-1 fail-open classes are closed at this
head, verified by 45 independent on-disk fixture mutations run against the
committed suite; 42 fail closed and the 3 that pass are bookkeeping-level
observations, not contract weakenings.

Battery (all in a detached worktree at the exact head):

  • git merge-base HEAD 1679045 prints 1679045 (clean restack onto the skeleton).
  • cargo test --locked -p cmtraceopen-parser --test sccm_correlation_contract: 12 passed.
  • cargo test --locked -p cmtraceopen-parser --test sccm_spine_contract: 136 passed.
  • cargo test --locked -p cmtraceopen-parser (full): 893 passed, 0 failed, 15 binaries.
  • cargo clippy --locked -p cmtraceopen-parser --all-targets -- -D warnings: clean.
  • cargo check --locked -p cmtraceopen-parser --target wasm32-unknown-unknown: clean.

Per-thread adjudication (probes mutate the committed fixtures on disk, then run
the committed suite; "red" means the suite fails):

  1. Guard-input binding: RESOLVED. guard_demonstrated now enforces a
    biconditional per guard (declared implies demonstrated, demonstrated implies
    declared). Replays of round-1 neutralizations on both matrices are red:
    same-time key Missing->Exact, Unrelated->Corroborating,
    InvalidOffset->Usable (content side), plus new directions: adding an
    undemonstrated rotation split without its label is red
    (demonstrated-but-undeclared), and dropping the guard label while keeping
    the adversarial state is red (declared-state coupling). 5/5 probes red.

  2. Decoded projection privacy: RESOLVED. Projection strings are inspected
    decoded (values and object keys, recursively) against a closed grammar
    (ASCII alphanumeric plus '-' and '.', nonempty, max 96) plus declared-marker
    containment. Decoded LAB\SyntheticUser as a value, an undeclared raw
    C:\Windows\CCM\Logs\PolicyAgent.log, a marker-shaped key, a doubled-escape
    form, a marker-bearing URL, and a nested-array leak are all red. 6/7 probes
    red. Noted limitation: a pure-alphanumeric base64 encoding of a marker
    passes the closed grammar because it is syntactically indistinguishable from
    a synthetic slug; this is inherent to syntactic checking of hand-authored
    expected values. Optional hardening: base64-decode candidate tokens and
    match against declared markers.

  3. Fixture-ref side/upstream binding: RESOLVED. repo: refs are valid only on
    merged sides under that side's own corpus prefix, must name an existing
    directory, and reject '..'; synthetic: refs are valid only on merged sides;
    issue: refs are valid only on the pending side with the pinned issue number;
    registry pair ownership and the #329 pending-acceptance blocker are pinned.
    10/10 probes red, including: the pending #329 side citing the merged DP
    corpus itself, wrong-side prefixes in both directions, traversal inside the
    prefix, a wrong issue number, dropping the #329 blocker, and rewriting the
    content pair server issue to #328.

  4. Executable requiredOutputs: RESOLVED. The obligation vocabulary is closed
    and pinned in the test; the shared matrix must match the pinned lists
    exactly, and every token has an executable predicate evaluated against the
    scenario's expected contract and projection. arbitraryOutput, a projection
    contradicting the ordering obligation, a projection stripped to outcome
    only, a single safe handle where two are required, and wrong-direction
    artifact requests are all red. 5/5 probes red.

  5. Reordered-input evidence: RESOLVED. A/B scenarios carry an
    orderedInputEvidence manifest of side-tagged synthetic tokens covering both
    sides; B must replay A's multiset in exactly opposite order with identical
    fixture refs, input state, expected contract, serialized projection, and
    result id. B replaying A's order, divergent refs, emptied evidence,
    reversed-but-renamed token, divergent result id, and single-side evidence
    are all red. 6/6 probes red.

Restack honesty (#329 pin): the wording matches reality at this head. The DP
preparation corpus (crates/cmtraceopen-parser/tests/fixtures/sccm/server/
distribution_point/) exists at the merge-base 1679045, so "merged on the
program baseline" is accurate; no production reducer for the #322/#329 pair
exists (src/sccm/ has no correlation module; src/sccm/server/windows/ is
per-side intake/catalog only), so "public fact interface not independently
accepted" is accurate; and the checker gives the pin teeth: the pending side
may not cite even the merged DP corpus via repo: or dodge into synthetic:,
and the registry blocker string is pinned.
correlation_preparation_contains_no_production_module passes and
src/sccm/correlation does not exist, so the PR remains contract-only.

Fresh-eyes closure checks (all red): unknown guard name in a scenario, a
fourteenth guard in the shared matrix, duplicate guard ids, unknown fields on
scenarios and registry pairs (deny_unknown_fields), unknown ceiling values,
scenario reordering, schemaVersion drift, appliesTo narrowing, and Candidate
pair promotion.

Non-blocking observations for a follow-up:

  1. deterministicResultId uniqueness is not enforced across unrelated scenarios
    (only nonemptiness plus reordered-pair equality); a copy-pasted or colliding
    id survives. Suggest asserting uniqueness modulo the reordered A/B pair.
  2. A scenario may cite the same synthetic: slug as both its client and server
    fixture ref, since synthetic slugs carry no side tag. Suggest requiring
    side-distinct refs.
  3. docs/sccm/preparation/issue-333-correlation-contracts.md line 12 still says
    "#329's DP corpus is not independently accepted on the program baseline";
    the README and test comments now correctly distinguish the merged corpus
    from the unaccepted fact interface. Suggest aligning the doc sentence.
  4. The closed projection grammar admits pure-alphanumeric base64 tokens (see
    thread 2 note).

Privacy sweep: the lane contains no non-ASCII bytes, no real hostnames, IPs,
GUIDs, SIDs, tenant values, or user identities. The only identity-shaped
strings are the reserved synthetic markers LAB\SyntheticUser and
LAB\SyntheticDevice and lab.invalid URLs, all declared as privateInputMarkers
whose exclusion from projections the suite proves.

This review applies to exact head cc7d2b5
only; any further push invalidates it.

@coderabbitai

coderabbitai Bot commented Jul 31, 2026 •

Copy link
Copy Markdown
✅ Action performed

Full review finished.


Your included review limit is currently reached under our Fair Usage Limits Policy. This review may still proceed through usage-based billing if eligible. Your next included review will be available in 3 minutes.

@adamgell
adamgell marked this pull request as ready for review July 31, 2026 21:17
Copilot AI review requested due to automatic review settings July 31, 2026 21:17
@adamgell
adamgell merged commit 2611602 into codex/parser-family-skeleton Jul 31, 2026
1 check passed

Copilot AI left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

🟡 Not ready to approve

The new #333 preparation doc’s “thirteen guards” table currently lists only 12 entries by combining missing-client and missing-server into one row, which is inconsistent with the fixture/test contract.

Once you've addressed the issues Copilot identified, you can request another Copilot review.

This review doesn't count toward merge requirements. Sign up for the private preview to control whether Copilot approvals count.

Pull request overview

This PR adds a test/fixture-only “correlation safety contract” scaffold for SCCM issue #333, defining non-executable pair registries and adversarial matrices that explicitly prevent high-confidence causal outputs until upstream fact interfaces stabilize.

Changes:

  • Adds a Rust contract test (sccm_correlation_contract) that validates a closed schema for pair registries, guard definitions, scenario matrices, and privacy-safe public projections.
  • Introduces shared + pair-specific adversarial matrix fixtures (policy↔MP and content↔DP) plus a non-executable pair-registry.json gated by blockers.
  • Documents the preparation scope, blockers, and evidence/fixture reference rules for the #333 slice.
File summaries
File Description
docs/sccm/preparation/issue-333-correlation-contracts.md Documents the #333 correlation-contract preparation scope, guard list, and evidence classification.
crates/cmtraceopen-parser/tests/sccm_correlation_contract.rs Adds executable contract tests enforcing closed/typed SCCM correlation contract fixtures and “no production module” guard.
crates/cmtraceopen-parser/tests/fixtures/sccm/correlation/shared/adversarial-matrix.json Defines the shared set of 13 false-causality guards and their pinned required outputs.
crates/cmtraceopen-parser/tests/fixtures/sccm/correlation/README.md Explains fixture intent, guard semantics, and allowed fixture reference forms (repo:, issue:, synthetic:, absent).
crates/cmtraceopen-parser/tests/fixtures/sccm/correlation/policy_management_point/adversarial-matrix.json Adds 14 policy↔MP adversarial scenarios instantiating all shared guards.
crates/cmtraceopen-parser/tests/fixtures/sccm/correlation/pair-registry.json Adds a non-executable registry of correlation pairs with explicit blockers and disabled production flags.
crates/cmtraceopen-parser/tests/fixtures/sccm/correlation/content_distribution_point/adversarial-matrix.json Adds 14 content↔DP adversarial scenarios instantiating all shared guards, with #329 scenarios kept as issue: refs.
Review details
  • Files reviewed: 7/7 changed files
  • Comments generated: 1
  • Review effort level: Lite

We're testing this review assessment. Please use 👍 or 👎 to tell us if it's correct.

Comment on lines +26 to +31
Each first pair instantiates all thirteen guards:

| Guard | Required conservative result |
| --- | --- |
| Missing client/server counterpart | Preserve source-local output and request only the named counterpart artifact group |
| Same-time/no-key | Candidate symptom at most; time is not a causal key |
adamgell added a commit that referenced this pull request Sep 25, 2026
… worktrees

CodeRabbit review 5, three threads: the checkpoint rows named preparation PRs that landed on codex/parser-family-skeleton (#340, #385, #377) rather than #490, which merged into main and closed #320/#329/#330 within seconds; the worktree counts contradicted the layout block below them and both were stale; and library.md called Aug 30 months newer than Aug 4-5 plans, which is about four weeks.
@adamgell
adamgell deleted the codex/sccm-333-correlation-contracts branch September 25, 2026 13:40
adamgell added a commit that referenced this pull request Oct 3, 2026
* docs: correct four checkpoint rows whose work merged weeks ago

`memory.md` and `soul.md` both carry a "Verified Checkpoints" table, and every row
is stale: all four issues merged weeks ago while the tables still say NOT
merge-ready, hold the PR until clean, full gate pending, findings outstanding.

| Issue | Table said | Verified 2026-09-24 |
|---|---|---|
| #320 client health | NOT merge-ready | merged via #340, issue closed 2026-08-05 |
| #329 DP lifecycle | P1 open, hold PR | merged via #385 |
| #330 SUP coverage | full gate pending | merged via #377 |
| #366 Intune CP | findings to address | merged via #460 |

The rows are not wrong about the *commits* — those SHAs are preserved on origin
branches — only about whether the work landed, which is the one thing the table
exists to say. `soul.md` prefixes it with "Always verify state before acting"; the
instruction was right and unheeded for seven weeks, including by the session that
found this.

Also notes the failure mode in `memory.md`, so the next reader knows the table
tracks pointers rather than state.

* docs: the recovery branches are accurate; their targets have landed

Verified rather than assumed, since this table gives instructions rather than just
describing state:

- **All six branches are still present on `origin`** with the SHAs listed, so the
  "preserve refs" instruction has held — the second artifact today that checks out
  exactly as written.
- **Their targets have landed.** `#365` and `#360` are done, `intune/apps/macos` and
  `intune/portal/{macos,ios_ipados}` exist on main, and the epic tracker marks the
  corresponding rows complete. So the second instruction — "check merged equivalents
  for closed macOS/iOS issues before any PR" — is answered rather than open.

The branches stay as evidence, which is what the heading already calls them. The note
records why, so the next reader does not treat them as pending work the way the
checkpoint table above invited.

* docs: the worktree forest is ~65, not 450+

Measured rather than read, since the line gives a number:

| Location | Count |
|---|---|
| `.worktrees/` | 34 (35 registered with `git worktree list`) |
| `~/.codex/worktrees/` | 28 |
| `/private/tmp/cmtraceopen-*` | 1 |
| repo `.claude/worktrees/` | 1 |
| `~/.claude/worktrees/` | 1 |

The forest is real — the description below the number holds, including the deep
branches and the parallel work — but it is a seventh of the size claimed. A count
nobody retakes decays in one direction only, and cleaning up merged lanes is exactly
what shrinks it.

Not updated: the "246 SCCM branches" line. My count matched 211 branches against a
looser pattern, which is not the same measurement, and a mismatched instrument is
what produced two wrong findings earlier today. It needs counting properly or being
marked as approximate.

* docs: the charter this table cites is not readable here

`memory.md` sources the checkpoint SHAs from `~/.hermes/cmtrace-pm-charter.md`, and the
CEO charter treats that path as required: "Main reads this charter ... If the contract is
absent or unreadable, Main fails closed before orchestration."

Checked 2026-09-24: **the path does not exist on this workstation**. So the citation
cannot be followed by a session that reads this table, which is a second reason the
SHAs need to be quoted in full rather than referenced — the first being that four of
them were stale.

The line now says the source is unreadable here and why the table stands alone. If the
charter is provisioned on the operator's machine only, this line should say that
instead of naming a path a session cannot open.

* docs: the routing index routes only into the past

`library.md` is what a session reads to find context: sixteen "IF <task> → read <plan>"
rules. Checked today, and **all thirteen issues and pull requests it names are closed or
merged** (#317, #490, #500, #512, #409, #441, #410, #414, #506, #507, #326, #321, #333).
The plan files themselves still exist, so nothing is broken — but nothing here is current
either.

`docs/superpowers/plans/` holds 40 files, several of them months newer (through
2026-08-30), and the index mentions none of them. So an agent following it is routed
exclusively into finished work, which is worse than an empty index: it looks like
guidance.

Flagged rather than rewritten. Regenerating the rules from the plans directory is
mechanical — one rule per file, date included — but deciding which subjects still matter
is a judgement about this repository's live work, and that is the owner's.

* docs(adr): ADR-005 is accepted; its own confirm-at-merge condition is met

The status line read "Proposed — recorded as the resolution of issue #635. Confirm at
merge." All three of those are now satisfied rather than pending:

- the resolution landed as `a7a21428` on `main` ("stop control and honest coverage for
  large explicit loads");
- PR #639 merged 2026-09-19;
- issue #635 is closed.

So the ADR asked to be confirmed at merge and was never advanced afterwards — the same
shape as the checkpoint table, one document class over: a normative record whose status
lags the work it governs. The revisit criteria keep their role; they are the trigger for
reopening, not a reason to leave the status proposed.

Checked the rest of the chain while I was here, and it is well maintained: ADR-004's base,
revision 1 and revision 2 each state what they supersede and what remains in force.

* docs: the gate list was understated in three files, not two

`CONTRIBUTING.md` and `CLAUDE.md` both said three checks where seven jobs run. So did
`memory.md`, in a one-line summary whose own heading names `CLAUDE.md` as its source —
which is the mechanism: a file copies a summary, the summary drifts, and the copies keep
its authority because each looks like a local statement rather than a citation.

Found by grepping for the phrase rather than assuming the pair I had already fixed was all
of them. The correction names the seven jobs, so the next copy has something to copy that
is right.

* docs: cite the landing PR for the merged checkpoints, and recount the worktrees

CodeRabbit review 5, three threads: the checkpoint rows named preparation PRs that landed on codex/parser-family-skeleton (#340, #385, #377) rather than #490, which merged into main and closed #320/#329/#330 within seconds; the worktree counts contradicted the layout block below them and both were stale; and library.md called Aug 30 months newer than Aug 4-5 plans, which is about four weeks.

* docs(library): leave library.md to #767

#767 rewrites library.md's routes. The note this branch added said the
routes point only at finished work and should be regenerated, which is
what #767 does, so the note would be wrong as soon as #767 merges.
Dropping it here also removes the conflict between the two PRs.

The memory.md, soul.md and ADR-005 corrections are unchanged.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs(memory): distinguish unreconciled historical worktree counts

* docs: preserve recovery history and correct SCCM landing references

---------

Co-authored-by: Adam Gell <adam@cmtraceopen.dev>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

enhancement New feature or request parser Log parser related sccm SCCM/ConfigMgr related test Testing related

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants