@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
475 lines (442 loc) • 16.6 kB
text/typescript
import type { CompatibilityVerdict } from "../constants";
import { LAB_PROJECTION_SPEC_VERSION } from "../constants";
import type { SuiteManifestV1 } from "../conformance/suite-manifest";
import { jcsStringify } from "../digest";
import type {
ClaimSnapshotEvent,
LabEvent,
LedgerCorruption,
ObservationEvent,
} from "../events/types";
import {
buildInvalidationIndex,
isEventExcluded,
usableClaims,
usableObservations,
type InvalidationIndex,
} from "../ledger/invalidation";
import {
evaluateAllApplicableRequiredPassV1,
newestObservationByScenario,
type ScenarioRequirements,
} from "./verification";
export interface ProjectionKey {
subjectId: string;
evidenceLayer: string;
suiteId: string;
suiteVersion: string;
suiteManifestDigest: string;
projectionSpecVersion: string;
}
function componentKey(parts: readonly string[]): string {
return jcsStringify([...parts]);
}
export function projectionKeyString(key: ProjectionKey): string {
return componentKey([
key.subjectId,
key.evidenceLayer,
key.suiteId,
key.suiteVersion,
key.suiteManifestDigest,
key.projectionSpecVersion,
]);
}
export function claimKeyString(subjectId: string, capability: string): string {
return componentKey([subjectId, capability]);
}
export interface DerivedVerdict {
key: ProjectionKey;
verdict: CompatibilityVerdict;
asOf: number;
scenarioManifestDigests: string[];
claimSourceDigest?: string;
contributingEventIds: string[];
contradictingEventIds: string[];
notes: string[];
}
export interface ClaimState {
key: string;
current: ClaimSnapshotEvent | null;
corruption?: string;
unusable?: boolean;
}
export interface ProjectVerdictsOptions {
asOf?: number;
index?: InvalidationIndex;
unusableObservationIds?: Set<string>;
unusableClaimEventIds?: Set<string>;
loadSuiteManifest?: (digest: string) => SuiteManifestV1 | null;
loadScenarioManifest?: (digest: string) => Record<string, unknown> | null;
loadScenarioRequirements?: (digest: string) => ScenarioRequirements | null;
}
/**
* Resolve current claims after purge/invalidation and supersession.
* Multiple unsuperseded claims, missing predecessors, cross-key supersession, or cycles → UNKNOWN + corruption.
*/
export function resolveClaimStates(
claims: ClaimSnapshotEvent[],
opts: {
unusableClaimEventIds?: Set<string>;
purgedEventIds?: ReadonlySet<string>;
} = {},
): {
states: Map<string, ClaimState>;
corruptions: LedgerCorruption[];
} {
const unusableClaims = opts.unusableClaimEventIds ?? new Set<string>();
const purgedEventIds = opts.purgedEventIds ?? new Set<string>();
const byKey = new Map<string, ClaimSnapshotEvent[]>();
const allById = new Map(claims.map((claim) => [claim.eventId, claim]));
for (const claim of claims) {
const key = claimKeyString(claim.subjectId, claim.capability);
const list = byKey.get(key) ?? [];
list.push(claim);
byKey.set(key, list);
}
const states = new Map<string, ClaimState>();
const corruptions: LedgerCorruption[] = [];
for (const [key, list] of byKey) {
const sorted = [...list].sort((a, b) => {
if (a.effectiveAt !== b.effectiveAt) return a.effectiveAt - b.effectiveAt;
if (a.recordedAt !== b.recordedAt) return a.recordedAt - b.recordedAt;
return a.eventId < b.eventId ? -1 : a.eventId > b.eventId ? 1 : 0;
});
const superseded = new Set<string>();
for (const claim of sorted) {
for (const pred of claim.supersedes) {
const prev = allById.get(pred);
if (!prev) {
if (purgedEventIds.has(pred)) {
// A purge may physically remove a superseded predecessor. The ID remains
// valid provenance but is not a live claim candidate.
continue;
}
corruptions.push({
kind: "claim_corruption",
eventId: claim.eventId,
detail: `missing supersedes predecessor ${pred}`,
});
states.set(key, { key, current: null, corruption: "missing predecessor" });
continue;
}
if (prev.subjectId !== claim.subjectId || prev.capability !== claim.capability) {
corruptions.push({
kind: "claim_corruption",
eventId: claim.eventId,
detail: "cross-key supersession",
});
states.set(key, { key, current: null, corruption: "cross-key supersession" });
continue;
}
superseded.add(pred);
}
}
if (states.get(key)?.corruption) continue;
const current = sorted.filter((c) => !superseded.has(c.eventId));
if (current.length > 1) {
corruptions.push({
kind: "claim_corruption",
detail: `multiple unsuperseded claims for ${key}`,
});
states.set(key, { key, current: null, corruption: "conflicting current claims" });
continue;
}
const currentClaim = current[0] ?? null;
states.set(key, {
key,
current: currentClaim,
unusable: currentClaim ? unusableClaims.has(currentClaim.eventId) : undefined,
});
}
return { states, corruptions };
}
function supportedClaimsForSubject(claimStates: Map<string, ClaimState>, subjectId: string): string[] {
const supported = new Set<string>();
for (const state of claimStates.values()) {
const claim = state.current;
if (!claim || state.corruption || state.unusable) continue;
if (claim.subjectId === subjectId && claim.polarity === "supported") supported.add(claim.capability);
}
return [...supported].sort();
}
/**
* CL-02 verdict projection primitives with frozen CL-00 verification semantics.
*/
export function projectVerdicts(
events: LabEvent[],
opts: ProjectVerdictsOptions = {},
): { verdicts: DerivedVerdict[]; corruptions: LedgerCorruption[]; index: InvalidationIndex } {
const index = opts.index ?? buildInvalidationIndex(events);
const corruptions = [...index.corruptions];
const unusableObs = opts.unusableObservationIds ?? new Set<string>();
const unusableClaims = opts.unusableClaimEventIds ?? new Set<string>();
const asOf =
opts.asOf ??
events.reduce((max, event) => {
if (event.eventKind === "observation") return Math.max(max, event.completedAt, event.recordedAt);
if (event.eventKind === "claim_snapshot") return Math.max(max, event.effectiveAt, event.recordedAt);
return Math.max(max, event.recordedAt);
}, 0);
const observations = usableObservations(events, index)
.filter((o) => o.completedAt <= asOf)
.filter((o) => !unusableObs.has(o.eventId));
const claims = usableClaims(events, index).filter((c) => c.effectiveAt <= asOf);
const { states: claimStates, corruptions: claimCorruptions } = resolveClaimStates(claims, {
unusableClaimEventIds: unusableClaims,
purgedEventIds: index.purgedEventIds,
});
corruptions.push(...claimCorruptions);
const groups = new Map<string, ObservationEvent[]>();
for (const obs of observations) {
const key: ProjectionKey = {
subjectId: obs.subjectId,
evidenceLayer: obs.evidenceLayer,
suiteId: obs.suiteId,
suiteVersion: obs.suiteVersion,
suiteManifestDigest: obs.suiteManifestDigest,
projectionSpecVersion: LAB_PROJECTION_SPEC_VERSION,
};
const ks = projectionKeyString(key);
const list = groups.get(ks) ?? [];
list.push(obs);
groups.set(ks, list);
}
const verdicts: DerivedVerdict[] = [];
for (const [, list] of groups) {
const sample = list[0]!;
const key: ProjectionKey = {
subjectId: sample.subjectId,
evidenceLayer: sample.evidenceLayer,
suiteId: sample.suiteId,
suiteVersion: sample.suiteVersion,
suiteManifestDigest: sample.suiteManifestDigest,
projectionSpecVersion: LAB_PROJECTION_SPEC_VERSION,
};
const ordered = [...list].sort((a, b) => {
if (a.completedAt !== b.completedAt) return a.completedAt - b.completedAt;
return a.eventId < b.eventId ? -1 : a.eventId > b.eventId ? 1 : 0;
});
const suiteManifest = opts.loadSuiteManifest?.(key.suiteManifestDigest) ?? null;
verdicts.push(
projectObservationGroup(key, ordered, asOf, suiteManifest, {
loadScenarioManifest: opts.loadScenarioManifest,
loadScenarioRequirements: opts.loadScenarioRequirements,
routeSupportedClaims: key.evidenceLayer === "live_route_compatibility"
? supportedClaimsForSubject(claimStates, key.subjectId)
: undefined,
}),
);
}
for (const [, state] of claimStates) {
if (!state.current || state.current.polarity !== "supported") continue;
if (state.corruption) continue;
const claim = state.current;
const key: ProjectionKey = {
subjectId: claim.subjectId,
evidenceLayer: "live_route_compatibility",
suiteId: "_claims",
suiteVersion: "1",
suiteManifestDigest: claim.sourceManifestDigest,
projectionSpecVersion: LAB_PROJECTION_SPEC_VERSION,
};
const ks = projectionKeyString(key);
if (verdicts.some((v) => projectionKeyString(v.key) === ks)) continue;
if (state.unusable) {
verdicts.push({
key,
verdict: "UNKNOWN",
asOf,
scenarioManifestDigests: [],
claimSourceDigest: claim.sourceManifestDigest,
contributingEventIds: [claim.eventId],
contradictingEventIds: [],
notes: ["current_claim_unusable"],
});
continue;
}
verdicts.push({
key,
verdict: "CLAIMED",
asOf,
scenarioManifestDigests: [],
claimSourceDigest: claim.sourceManifestDigest,
contributingEventIds: [claim.eventId],
contradictingEventIds: [],
notes: ["claim_snapshot"],
});
}
return { verdicts, corruptions, index };
}
function isMatchedCapabilityAbsenceControl(obs: ObservationEvent): boolean {
const expected = obs.expectedFailure;
return (
obs.outcome === "pass" &&
!!expected &&
expected.controlKind === "capability_absence_control" &&
expected.onMatch === "unsupported"
);
}
function evaluateRequiredPassVerdict(input: {
suiteManifest: SuiteManifestV1 | null;
ordered: ObservationEvent[];
executionMode: ObservationEvent["executionMode"];
subject?: ObservationEvent["subject"];
routeSupportedClaims?: readonly string[];
fabricCapability?: {
harnessFeatures: readonly string[];
platforms: readonly string[];
routePreconditions: readonly string[];
};
loadScenarioManifest?: (digest: string) => Record<string, unknown> | null;
loadScenarioRequirements?: ProjectVerdictsOptions["loadScenarioRequirements"];
asOf: number;
}): { verdict: CompatibilityVerdict; notes: string[] } {
const notes: string[] = [];
if (!input.suiteManifest) {
return { verdict: "PROBED", notes: ["suite_manifest_unavailable"] };
}
const evaluation = evaluateAllApplicableRequiredPassV1(
input.suiteManifest,
input.ordered,
input.executionMode,
{
subject: input.subject,
routeSupportedClaims: input.routeSupportedClaims,
fabricCapability: input.fabricCapability,
loadScenarioManifest: input.loadScenarioManifest,
loadScenarioRequirements: input.loadScenarioRequirements,
asOf: input.asOf,
},
);
notes.push(...evaluation.notes);
if (evaluation.applicableRequiredScenarioIds.length === 0) {
return { verdict: "UNKNOWN", notes };
}
if (evaluation.canVerify) {
notes.push("all-applicable-required-pass-v1");
return { verdict: "VERIFIED", notes };
}
notes.push("incomplete_required_coverage");
return { verdict: "PROBED", notes };
}
function projectObservationGroup(
key: ProjectionKey,
ordered: ObservationEvent[],
asOf: number,
suiteManifest: SuiteManifestV1 | null,
opts: {
loadScenarioManifest?: (digest: string) => Record<string, unknown> | null;
loadScenarioRequirements?: ProjectVerdictsOptions["loadScenarioRequirements"];
routeSupportedClaims?: readonly string[];
fabricCapability?: {
harnessFeatures: readonly string[];
platforms: readonly string[];
routePreconditions: readonly string[];
};
} = {},
): DerivedVerdict {
const contributing: string[] = [];
const contradicting: string[] = [];
const digests = new Set<string>();
const notes: string[] = [];
for (const obs of ordered) {
digests.add(obs.scenarioManifestDigest);
contributing.push(obs.eventId);
if (obs.outcome === "fail") contradicting.push(obs.eventId);
}
const newest = newestObservationByScenario(ordered);
const currentObservations = [...newest.values()];
const currentFails = currentObservations.filter((o) => o.outcome === "fail");
const currentPasses = currentObservations.filter((o) => o.outcome === "pass");
const currentBlocked = currentObservations.some((o) => o.outcome === "blocked");
const currentInconclusive = currentObservations.some((o) => o.outcome === "inconclusive");
const matchedCapabilityAbsence = currentObservations.some(isMatchedCapabilityAbsenceControl);
const currentModes = new Set(currentObservations.map((o) => o.executionMode));
const newestCurrent = [...currentObservations].sort((a, b) => {
if (a.completedAt !== b.completedAt) return a.completedAt - b.completedAt;
return a.eventId < b.eventId ? -1 : a.eventId > b.eventId ? 1 : 0;
}).at(-1);
let verdict: CompatibilityVerdict = "UNKNOWN";
if (
key.evidenceLayer !== "protocol_conformance" &&
key.evidenceLayer !== "live_route_compatibility" &&
key.evidenceLayer !== "task_effectiveness"
) {
verdict = "UNKNOWN";
} else if (matchedCapabilityAbsence) {
verdict = "UNSUPPORTED";
notes.push("capability_absence_control");
} else if (currentFails.length > 0) {
verdict = "DEGRADED";
} else if (currentPasses.length > 0 && !currentInconclusive && !currentBlocked) {
if (currentModes.size > 1) {
verdict = "PROBED";
notes.push("mixed_execution_modes");
} else if (key.evidenceLayer === "protocol_conformance" && newestCurrent?.executionMode === "fixture") {
const evaluated = evaluateRequiredPassVerdict({
suiteManifest,
ordered,
executionMode: newestCurrent.executionMode,
subject: newestCurrent.subject.subjectKind === "protocol" ? newestCurrent.subject : undefined,
loadScenarioManifest: opts.loadScenarioManifest,
loadScenarioRequirements: opts.loadScenarioRequirements,
asOf,
});
verdict = evaluated.verdict;
notes.push(...evaluated.notes);
} else if (key.evidenceLayer === "live_route_compatibility" && newestCurrent?.executionMode === "live") {
const evaluated = evaluateRequiredPassVerdict({
suiteManifest,
ordered,
executionMode: newestCurrent.executionMode,
subject: newestCurrent.subject.subjectKind === "route" ? newestCurrent.subject : undefined,
routeSupportedClaims: opts.routeSupportedClaims,
loadScenarioManifest: opts.loadScenarioManifest,
loadScenarioRequirements: opts.loadScenarioRequirements,
asOf,
});
verdict = evaluated.verdict;
notes.push(...evaluated.notes);
} else if (key.evidenceLayer === "task_effectiveness" && newestCurrent?.executionMode === "fabric") {
const evaluated = evaluateRequiredPassVerdict({
suiteManifest,
ordered,
executionMode: newestCurrent.executionMode,
subject: newestCurrent.subject.subjectKind === "task" ? newestCurrent.subject : undefined,
fabricCapability: opts.fabricCapability ?? {
harnessFeatures: ["fabric-scratch-v1"],
platforms: [process.platform, "*"],
routePreconditions: ["exact-route-subject"],
},
loadScenarioManifest: opts.loadScenarioManifest,
loadScenarioRequirements: opts.loadScenarioRequirements,
asOf,
});
verdict = evaluated.verdict;
notes.push(...evaluated.notes);
} else {
verdict = "PROBED";
}
} else if (currentPasses.length > 0) {
verdict = "PROBED";
} else if (currentBlocked) {
verdict = "BLOCKED";
} else {
verdict = "UNKNOWN";
}
return {
key,
verdict,
asOf,
scenarioManifestDigests: [...digests].sort(),
contributingEventIds: contributing,
contradictingEventIds: contradicting,
notes,
};
}
export function excludeEventIds(index: InvalidationIndex): Set<string> {
const out = new Set<string>([...index.purgedEventIds]);
for (const id of index.invalidatedBy.keys()) out.add(id);
return out;
}
export { isEventExcluded };