@iislee/opencodex 2.11.0 → 2.31.0

package/src/lab/fabric/manifest.ts

@@ -0,0 +1,222 @@
+import type { CaseRecord, VerificationRole } from "../conformance/types";
+import { fixtureDigest, scenarioManifestDigest, suiteManifestDigest } from "../digest";
+import {
+  FABRIC_EVIDENCE_LAYER,
+  FABRIC_LIMITS,
+  FABRIC_SCENARIO_ID,
+  FABRIC_SCENARIO_VERSION,
+  FABRIC_SUITE_ID,
+  FABRIC_SUITE_VERSION,
+  FABRIC_TASK_CLASS_ID,
+  SYNTHETIC_AFTER_UTF8,
+  SYNTHETIC_BEFORE_UTF8,
+  SYNTHETIC_VALUE_PATH,
+} from "./constants";
+import { verifierManifestDigest } from "./subject";
+
+/** In-memory authority for the frozen CL-07 fabric scenario catalogue. */
+export interface FabricCaseAuthority {
+  schemaVersion: number;
+  sourceCommit: string;
+  assertionDslVersion: string;
+  evidenceSchemaVersion: string;
+  manifestDefaults: {
+    version: string;
+    suiteVersion: string;
+    evidenceLayer: typeof FABRIC_EVIDENCE_LAYER;
+    verificationRole: VerificationRole;
+    freshness: { maxAgeMs: number | null };
+    executionLimits: Record<string, number | null>;
+    artifactPolicy: Record<string, unknown>;
+  };
+  cases: CaseRecord[];
+}
+
+const FABRIC_SOURCE_COMMIT = "b66e33ce7207d91014644d99317e456c992a3418";
+const FIXTURE_BYTES_UTF8 = JSON.stringify({
+  path: SYNTHETIC_VALUE_PATH,
+  before: SYNTHETIC_BEFORE_UTF8,
+  after: SYNTHETIC_AFTER_UTF8,
+});
+
+/** Frozen CL-07 fabric scenario authority loaded from compiled constants. */
+export function loadFabricCaseAuthority(): FabricCaseAuthority {
+  const fixtureBytes = new TextEncoder().encode(FIXTURE_BYTES_UTF8);
+  const digest = fixtureDigest(fixtureBytes);
+  return {
+    schemaVersion: 1,
+    sourceCommit: FABRIC_SOURCE_COMMIT,
+    assertionDslVersion: "1.0.0",
+    evidenceSchemaVersion: "1.0.0",
+    manifestDefaults: {
+      version: FABRIC_SCENARIO_VERSION,
+      suiteVersion: FABRIC_SUITE_VERSION,
+      evidenceLayer: FABRIC_EVIDENCE_LAYER,
+      verificationRole: "required",
+      freshness: { maxAgeMs: 2_592_000_000 },
+      executionLimits: {
+        totalTimeoutMs: FABRIC_LIMITS.totalTimeoutMs,
+        inactivityTimeoutMs: FABRIC_LIMITS.inactivityTimeoutMs,
+        maxInputBytes: FABRIC_LIMITS.maxAggregateIoBytes,
+        maxOutputBytes: FABRIC_LIMITS.maxAggregateIoBytes,
+        maxArtifactBytes: FABRIC_LIMITS.aggregateArtifactBytes,
+        maxRequests: 0,
+        maxToolCalls: 0,
+        maxOutputTokens: null,
+        connectTimeoutMs: null,
+        firstByteTimeoutMs: null,
+      },
+      artifactPolicy: {
+        retain: ["verifier_summary", "normalized_tree_diff", "execution_metadata"],
+        forbid: ["file_bodies", "prompts", "raw_logs"],
+      },
+    },
+    cases: [{
+      id: FABRIC_SCENARIO_ID,
+      suite: FABRIC_SUITE_ID,
+      capability: FABRIC_TASK_CLASS_ID,
+      verificationRole: "required",
+      requirements: {
+        inboundProtocols: [],
+        upstreamProtocols: [],
+        surfaces: [],
+        requiredClaims: [],
+        requiredHarnessFeatures: ["fabric-scratch-v1"],
+        platforms: ["*"],
+        routePreconditions: ["exact-route-subject"],
+      },
+      fixture: {
+        id: "fabric-core.task.synthetic-patch.fixture",
+        role: "adapter_vector",
+        mediaType: "application/json",
+        bytesUtf8: FIXTURE_BYTES_UTF8,
+        digest,
+      },
+      assertions: [{
+        id: "exact-tree-diff-pass",
+        operator: "equals",
+        selector: "/verifier/passed",
+        expected: true,
+        required: true,
+      }],
+    }],
+  };
+}
+
+/** List fabric scenarios, optionally filtered by suite id. */
+export function discoverFabricScenarios(
+  authority: FabricCaseAuthority = loadFabricCaseAuthority(),
+  suites?: readonly string[],
+): CaseRecord[] {
+  return authority.cases.filter((row) => !suites || suites.includes(row.suite));
+}
+
+/** Expand a fabric case into the canonical scenario manifest object. */
+export function expandFabricScenario(
+  caseRecord: CaseRecord,
+  authority: FabricCaseAuthority = loadFabricCaseAuthority(),
+): Record<string, unknown> {
+  const defaults = authority.manifestDefaults;
+  return {
+    schemaVersion: authority.schemaVersion,
+    id: caseRecord.id,
+    version: defaults.version,
+    suite: {
+      id: caseRecord.suite,
+      version: defaults.suiteVersion,
+      evidenceLayer: defaults.evidenceLayer,
+    },
+    evidenceLayer: defaults.evidenceLayer,
+    capability: caseRecord.capability,
+    verificationRole: caseRecord.verificationRole ?? defaults.verificationRole,
+    requirements: caseRecord.requirements,
+    fixtures: [{
+      id: caseRecord.fixture.id,
+      role: caseRecord.fixture.role,
+      mediaType: caseRecord.fixture.mediaType,
+      digest: caseRecord.fixture.digest,
+      byteLength: Buffer.byteLength(caseRecord.fixture.bytesUtf8, "utf8"),
+      syntheticMarker: "ocx-lab-synthetic-v1",
+      provenance: {
+        kind: "lab_authored",
+        authority: "007_cl07_task_effectiveness.md",
+        sourceCommit: authority.sourceCommit,
+      },
+    }],
+    executionLimits: defaults.executionLimits,
+    assertions: caseRecord.assertions,
+    failureRules: [
+      {
+        id: "verifier-fail",
+        match: ["behavioral_failure"],
+        classification: "behavioral_failure",
+        verdictEffect: "degraded",
+        retry: "never",
+        expected: false,
+      },
+      {
+        id: "sandbox-block",
+        match: ["sandbox_violation"],
+        classification: "sandbox_violation",
+        verdictEffect: "none",
+        retry: "bounded",
+        expected: false,
+      },
+      {
+        id: "timeout-block",
+        match: ["timeout", "inactivity_timeout", "budget_exhausted"],
+        classification: "timeout",
+        verdictEffect: "none",
+        retry: "bounded",
+        expected: false,
+      },
+    ],
+    artifactPolicy: defaults.artifactPolicy,
+    freshness: defaults.freshness,
+    verifierManifestDigest: verifierManifestDigest(),
+  };
+}
+
+/** Expand a fabric suite id into the canonical suite manifest object. */
+export function expandFabricSuiteManifest(
+  suiteId: string = FABRIC_SUITE_ID,
+  authority: FabricCaseAuthority = loadFabricCaseAuthority(),
+): Record<string, unknown> {
+  const cases = authority.cases.filter((row) => row.suite === suiteId);
+  if (cases.length === 0) throw new Error(`unknown fabric suite ${suiteId}`);
+  const defaults = authority.manifestDefaults;
+  return {
+    schemaVersion: 1,
+    id: suiteId,
+    version: defaults.suiteVersion,
+    evidenceLayer: defaults.evidenceLayer,
+    capability: cases[0]!.capability,
+    assertionDslVersion: authority.assertionDslVersion,
+    evidenceSchemaVersion: authority.evidenceSchemaVersion,
+    freshness: defaults.freshness,
+    contradictionRule: "newest-required-observation-v1",
+    scenarios: cases.map((caseRecord) => ({
+      id: caseRecord.id,
+      version: defaults.version,
+      role: caseRecord.verificationRole ?? defaults.verificationRole,
+      manifestDigest: scenarioManifestDigest(expandFabricScenario(caseRecord, authority)),
+    })),
+    verificationRule: "all-applicable-required-pass-v1",
+  };
+}
+
+/** Digest of the expanded fabric scenario manifest for a case. */
+export function fabricScenarioManifestDigest(
+  caseRecord: CaseRecord = loadFabricCaseAuthority().cases[0]!,
+  authority: FabricCaseAuthority = loadFabricCaseAuthority(),
+): string {
+  return scenarioManifestDigest(expandFabricScenario(caseRecord, authority));
+}
+
+/** Digest of the expanded fabric suite manifest. */
+export function fabricSuiteManifestDigest(
+  suiteId: string = FABRIC_SUITE_ID,
+  authority: FabricCaseAuthority = loadFabricCaseAuthority(),
+): string {
+  return suiteManifestDigest(expandFabricSuiteManifest(suiteId, authority));
+}