@iislee/opencodex 2.11.0 → 2.31.0

package/src/lab/conformance/jcs.ts

@@ -0,0 +1,64 @@
+/** RFC 8785 JSON Canonicalization Scheme (JCS) for deterministic equality. */
+
+function assertValidUnicodeScalarString(value: string): void {
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code >= 0xd800 && code <= 0xdbff) {
+      const next = value.charCodeAt(index + 1);
+      if (!(next >= 0xdc00 && next <= 0xdfff)) {
+        throw new TypeError("jcsStringify: lone UTF-16 surrogate is not valid Unicode");
+      }
+      index += 1;
+      continue;
+    }
+    if (code >= 0xdc00 && code <= 0xdfff) {
+      throw new TypeError("jcsStringify: lone UTF-16 surrogate is not valid Unicode");
+    }
+  }
+}
+
+function stringifyJcsString(value: string): string {
+  assertValidUnicodeScalarString(value);
+  return JSON.stringify(value);
+}
+
+function assertDenseJsonArray(value: readonly unknown[]): void {
+  for (let index = 0; index < value.length; index += 1) {
+    if (!Object.prototype.hasOwnProperty.call(value, index)) {
+      throw new TypeError("jcsStringify: sparse arrays / array holes are not representable in JCS");
+    }
+  }
+  for (const key of Object.keys(value)) {
+    if (!/^(?:0|[1-9]\d*)$/.test(key) || Number(key) >= value.length) {
+      throw new TypeError("jcsStringify: arrays with extra enumerable properties are not representable in JCS");
+    }
+  }
+}
+
+export function jcsStringify(value: unknown): string {
+  if (value === undefined) throw new TypeError("jcsStringify: undefined is not representable in JCS");
+  if (value === null || typeof value === "boolean") return JSON.stringify(value);
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new TypeError("jcsStringify: non-finite numbers are not representable in JCS");
+    return JSON.stringify(value);
+  }
+  if (typeof value === "string") return stringifyJcsString(value);
+  if (Array.isArray(value)) {
+    assertDenseJsonArray(value);
+    return `[${value.map(jcsStringify).join(",")}]`;
+  }
+  if (typeof value === "object") {
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+      throw new TypeError("jcsStringify: only plain JSON objects are representable in JCS");
+    }
+    const obj = value as Record<string, unknown>;
+    const keys = Object.keys(obj).sort();
+    return `{${keys.map((key) => `${stringifyJcsString(key)}:${jcsStringify(obj[key])}`).join(",")}}`;
+  }
+  throw new TypeError(`jcsStringify: unsupported value type ${typeof value}`);
+}
+
+export function jcsEqual(a: unknown, b: unknown): boolean {
+  return jcsStringify(a) === jcsStringify(b);
+}

package/src/lab/conformance/json-pointer.ts

@@ -0,0 +1,39 @@
+/** RFC 6901 JSON Pointer resolution for assertion selectors. */
+
+export type PointerResult =
+  | { ok: true; value: unknown }
+  | { ok: false; reason: "selector_missing" | "selector_type_mismatch" };
+
+function decodeToken(token: string): string {
+  return token.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+
+export function resolveJsonPointer(root: unknown, pointer: string): PointerResult {
+  if (!pointer.startsWith("/")) return { ok: false, reason: "selector_missing" };
+  if (pointer === "/") return { ok: true, value: root };
+  const tokens = pointer.slice(1).split("/").map(decodeToken);
+  let current: unknown = root;
+  for (const token of tokens) {
+    if (token === "-") return { ok: false, reason: "selector_missing" };
+    if (Array.isArray(current)) {
+      if (!/^(0|[1-9][0-9]*)$/.test(token)) return { ok: false, reason: "selector_missing" };
+      const index = Number(token);
+      if (index >= current.length) return { ok: false, reason: "selector_missing" };
+      current = current[index];
+      continue;
+    }
+    if (current === null || typeof current !== "object") {
+      return { ok: false, reason: "selector_missing" };
+    }
+    const obj = current as Record<string, unknown>;
+    if (!Object.prototype.hasOwnProperty.call(obj, token)) {
+      return { ok: false, reason: "selector_missing" };
+    }
+    current = obj[token];
+  }
+  return { ok: true, value: current };
+}
+
+export function pointerExists(root: unknown, pointer: string): boolean {
+  return resolveJsonPointer(root, pointer).ok;
+}

package/src/lab/conformance/manifest.ts

@@ -0,0 +1,180 @@
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { fixtureDigest } from "./digest";
+import { MCP_ACTION_TOKENS } from "./mcp-stub";
+import type {
+  CaseAuthority,
+  CaseRecord,
+  FailureClassification,
+  FailureRule,
+} from "./types";
+import { CL01_SUITES, SYNTHETIC_MARKER } from "./types";
+
+const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
+// Provenance is the normative CL-00 authority name, not the runtime copy's basename.
+const AUTHORITY_FILE = "022_protocol_v1_cases.json";
+
+export function loadCaseAuthority(): CaseAuthority {
+  const path = join(MODULE_DIR, "fixtures", "protocol-v1-cases.json");
+  const raw = JSON.parse(readFileSync(path, "utf8")) as CaseAuthority;
+  validateAuthority(raw);
+  return raw;
+}
+
+export function discoverScenarios(
+  authority: CaseAuthority,
+  suites: readonly string[] = CL01_SUITES,
+): CaseRecord[] {
+  return authority.cases.filter((c) => suites.includes(c.suite));
+}
+
+export function expandScenario(caseRecord: CaseRecord, authority: CaseAuthority): Record<string, unknown> {
+  const defaults = authority.manifestDefaults;
+  const fixtures = caseRecord.initiatingRequest
+    ? [fixtureRef(caseRecord.initiatingRequest, authority), fixtureRef(caseRecord.fixture, authority)]
+    : [fixtureRef(caseRecord.fixture, authority)];
+  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,
+    executionLimits: defaults.executionLimits,
+    assertions: caseRecord.assertions,
+    ...(caseRecord.expectedFailure ? { expectedFailure: caseRecord.expectedFailure } : {}),
+    failureRules: expandFailureRules(caseRecord, authority),
+    artifactPolicy: defaults.artifactPolicy,
+    freshness: defaults.freshness,
+  };
+}
+
+function fixtureRef(fixture: CaseRecord["fixture"], authority: CaseAuthority): Record<string, unknown> {
+  const bytes = new TextEncoder().encode(fixture.bytesUtf8);
+  return {
+    id: fixture.id,
+    role: fixture.role,
+    mediaType: fixture.mediaType,
+    digest: fixture.digest,
+    byteLength: bytes.byteLength,
+    syntheticMarker: SYNTHETIC_MARKER,
+    provenance: {
+      kind: "lab_authored",
+      authority: AUTHORITY_FILE,
+      sourceCommit: authority.sourceCommit,
+    },
+  };
+}
+
+function expandFailureRules(caseRecord: CaseRecord, authority: CaseAuthority): FailureRule[] {
+  const setName = authority.manifestDefaults.failureRuleSet;
+  const ruleSet = authority.failureRuleSets[setName];
+  if (!Array.isArray(ruleSet)) {
+    throw new Error(`harness_failure: contract_integrity unknown failureRuleSet ${setName}`);
+  }
+  const base = [...ruleSet];
+  if (!caseRecord.expectedFailure) return base;
+  const template = authority.expectedFailureRuleTemplate;
+  const controlRule: FailureRule = {
+    id: template.id,
+    match: [...template.match],
+    classification: caseRecord.expectedFailure.expectedClass as FailureClassification,
+    secondaryCode: caseRecord.expectedFailure.expectedCode,
+    verdictEffect: caseRecord.expectedFailure.onMatch === "unsupported" ? "unsupported" : "none",
+    retry: template.retry,
+    expected: template.expected,
+  };
+  const idx = base.findIndex((r) => r.id === "required-assertion");
+  if (idx >= 0) base.splice(idx, 0, controlRule);
+  else base.push(controlRule);
+  return base;
+}
+
+export function validateFixtureDigests(caseRecord: CaseRecord): string[] {
+  const errors: string[] = [];
+  const check = (fixture: CaseRecord["fixture"], label: string) => {
+    const bytes = new TextEncoder().encode(fixture.bytesUtf8);
+    const digest = fixtureDigest(bytes);
+    if (digest !== fixture.digest) {
+      errors.push(`${label} digest mismatch: expected ${fixture.digest}, got ${digest}`);
+    }
+  };
+  check(caseRecord.fixture, caseRecord.fixture.id);
+  if (caseRecord.initiatingRequest) check(caseRecord.initiatingRequest, caseRecord.initiatingRequest.id);
+  return errors;
+}
+
+export function validateExpandedFixtureRef(
+  ref: Record<string, unknown>,
+  authority: CaseAuthority,
+  fixtureBytes: string,
+): string[] {
+  const errors: string[] = [];
+  const bytes = new TextEncoder().encode(fixtureBytes);
+  if (ref.syntheticMarker !== SYNTHETIC_MARKER) {
+    errors.push(`invalid syntheticMarker: ${String(ref.syntheticMarker)}`);
+  }
+  const provenance = ref.provenance as Record<string, unknown> | undefined;
+  if (!provenance || provenance.kind !== "lab_authored") {
+    errors.push("invalid provenance kind");
+  } else if (provenance.authority !== AUTHORITY_FILE) {
+    errors.push(`invalid provenance authority: ${String(provenance.authority)}`);
+  } else if (provenance.sourceCommit !== authority.sourceCommit) {
+    errors.push(`invalid provenance sourceCommit: ${String(provenance.sourceCommit)}`);
+  }
+  if (ref.digest !== fixtureDigest(bytes)) {
+    errors.push("fixture digest mismatch in expanded ref");
+  }
+  if (ref.byteLength !== bytes.byteLength) {
+    errors.push("fixture byteLength mismatch in expanded ref");
+  }
+  return errors;
+}
+
+function validateMcpHarnessFeatures(caseRecord: CaseRecord): string[] {
+  if (caseRecord.suite !== "mcp-core") return [];
+  const tokens = caseRecord.requirements.requiredHarnessFeatures.filter(
+    (f) => MCP_ACTION_TOKENS.includes(f as typeof MCP_ACTION_TOKENS[number]),
+  );
+  if (tokens.length !== 1) {
+    return [`${caseRecord.id}: invalid_manifest MCP action token count ${tokens.length}`];
+  }
+  if (caseRecord.fixture.role !== "synthetic_tool") {
+    return [`${caseRecord.id}: MCP cases require synthetic_tool fixture role`];
+  }
+  return [];
+}
+
+function validateAuthority(authority: CaseAuthority): void {
+  if (authority.schemaVersion !== 1) throw new Error("unsupported schemaVersion");
+  if (!authority.sourceCommit || typeof authority.sourceCommit !== "string") {
+    throw new Error("missing sourceCommit");
+  }
+  if (!Array.isArray(authority.cases) || authority.cases.length === 0) throw new Error("no cases");
+  for (const caseRecord of authority.cases) {
+    const errors = [
+      ...validateFixtureDigests(caseRecord),
+      ...validateMcpHarnessFeatures(caseRecord),
+    ];
+    const expanded = expandScenario(caseRecord, authority);
+    const fixtures = expanded.fixtures as Array<Record<string, unknown>>;
+    for (let i = 0; i < fixtures.length; i++) {
+      const fixtureSource = i === 0 && caseRecord.initiatingRequest
+        ? caseRecord.initiatingRequest.bytesUtf8
+        : caseRecord.fixture.bytesUtf8;
+      errors.push(...validateExpandedFixtureRef(fixtures[i], authority, fixtureSource));
+    }
+    if (errors.length > 0) throw new Error(errors.join("; "));
+    if (caseRecord.fixture.role === "upstream_response" && !caseRecord.initiatingRequest) {
+      throw new Error(`${caseRecord.id}: upstream_response without initiatingRequest`);
+    }
+  }
+}

package/src/lab/conformance/mcp-stub.ts

@@ -0,0 +1,179 @@
+import type { CaseRecord, NormalizedObservation } from "./types";
+import { emptyObservation, projectMcpCalls, setClientResponse } from "./observation";
+
+export const MCP_ACTION_TOKENS = [
+  "mcp_namespace_round_trip_v1",
+  "mcp_schema_bounds_v1",
+  "mcp_call_result_v1",
+  "mcp_resource_round_trip_v1",
+] as const;
+
+export type McpActionToken = typeof MCP_ACTION_TOKENS[number];
+
+export function mcpActionToken(caseRecord: CaseRecord): McpActionToken | null {
+  const features = caseRecord.requirements.requiredHarnessFeatures;
+  const tokens = features.filter((f) => MCP_ACTION_TOKENS.includes(f as McpActionToken));
+  if (tokens.length !== 1) return null;
+  return tokens[0] as McpActionToken;
+}
+
+export function executeMcpSyntheticAction(caseRecord: CaseRecord): NormalizedObservation {
+  const token = mcpActionToken(caseRecord);
+  if (!token) throw new Error(`invalid_manifest: missing or ambiguous MCP action token for ${caseRecord.id}`);
+  const decoded = JSON.parse(caseRecord.fixture.bytesUtf8) as Record<string, unknown>;
+  switch (token) {
+    case "mcp_namespace_round_trip_v1":
+      return runNamespaceRoundTrip(decoded);
+    case "mcp_schema_bounds_v1":
+      return runSchemaBounds(decoded);
+    case "mcp_call_result_v1":
+      return runCallResult(decoded);
+    case "mcp_resource_round_trip_v1":
+      return runResourceRoundTrip(decoded);
+  }
+}
+
+function nonEmptyString(value: unknown): value is string {
+  return typeof value === "string" && value.length > 0;
+}
+
+function runNamespaceRoundTrip(decoded: Record<string, unknown>): NormalizedObservation {
+  if (!nonEmptyString(decoded.namespace) || !nonEmptyString(decoded.name)) {
+    throw new Error("invalid_manifest: MCP namespace/name must be non-empty strings");
+  }
+  const namespace = decoded.namespace;
+  const name = decoded.name;
+  const wireName = `${namespace}__${name}`;
+  const observation = emptyObservation();
+  observation.upstream.requests.push({
+    status: 0,
+    headers: {},
+    json: {
+      model: "fixture-model",
+      tools: [{
+        name: wireName,
+        description: decoded.description,
+        inputSchema: decoded.inputSchema,
+      }],
+    },
+    rawBytes: 0,
+  });
+  const toolCalls = [{
+    id: "call_fixture",
+    name: wireName,
+    arguments: {},
+    kind: "function" as const,
+    ordinal: 0,
+  }];
+  setClientResponse(observation, {
+    toolCalls,
+    mcpCalls: projectMcpCalls(toolCalls),
+    status: 200,
+  });
+  return observation;
+}
+
+function utf8ByteLength(value: string): number {
+  return new TextEncoder().encode(value).byteLength;
+}
+
+function parsesJson(value: string): boolean {
+  try {
+    JSON.parse(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function runSchemaBounds(decoded: Record<string, unknown>): NormalizedObservation {
+  const observation = emptyObservation();
+  const limitBytes = decoded.limitBytes;
+  const exactSchema = decoded.exactSchema;
+  const overSchema = decoded.overSchema;
+  if (!Number.isInteger(limitBytes) || (limitBytes as number) <= 0
+    || typeof exactSchema !== "string" || typeof overSchema !== "string") {
+    observation.verifiers = {
+      exact_bound: "fail",
+      one_over_rejected: "fail",
+      partial_commit: false,
+    };
+    return observation;
+  }
+
+  const limit = limitBytes as number;
+  const exactValid = utf8ByteLength(exactSchema) === limit && parsesJson(exactSchema);
+  // The inert stub models two isolated catalogue transactions. The over-bound transaction
+  // is rejected before commit; its validity matters so this tests the byte ceiling rather
+  // than malformed JSON.
+  const overRejected = utf8ByteLength(overSchema) === limit + 1 && parsesJson(overSchema);
+  observation.verifiers = {
+    exact_bound: exactValid ? "pass" : "fail",
+    one_over_rejected: overRejected ? "pass" : "fail",
+    partial_commit: false,
+  };
+  return observation;
+}
+
+function runCallResult(decoded: Record<string, unknown>): NormalizedObservation {
+  if (!nonEmptyString(decoded.namespace) || !nonEmptyString(decoded.name)) {
+    throw new Error("invalid_manifest: MCP namespace/name must be non-empty strings");
+  }
+  const namespace = decoded.namespace;
+  const name = decoded.name;
+  const argumentsValue = decoded.arguments ?? {};
+  const result = decoded.result;
+  const wireName = `${namespace}__${name}`;
+  const observation = emptyObservation();
+  const toolCalls = [{
+    id: "call_fixture",
+    name: wireName,
+    arguments: argumentsValue,
+    kind: "function" as const,
+    ordinal: 0,
+  }];
+  setClientResponse(observation, {
+    toolCalls,
+    mcpCalls: projectMcpCalls(toolCalls),
+    json: result,
+    status: 200,
+  });
+  observation.verifiers = {
+    stub_received: { namespace, name, arguments: argumentsValue },
+  };
+  return observation;
+}
+
+function runResourceRoundTrip(decoded: Record<string, unknown>): NormalizedObservation {
+  if (!Array.isArray(decoded.resources) || !decoded.read || typeof decoded.read !== "object") {
+    throw new Error("invalid_manifest: invalid MCP resource fixture");
+  }
+  const read = decoded.read as { uri?: unknown; contents?: unknown[] };
+  if (!nonEmptyString(read.uri) || !Array.isArray(read.contents)) {
+    throw new Error("invalid_manifest: invalid MCP resource read fixture");
+  }
+  const matching = decoded.resources.filter((resource) =>
+    resource && typeof resource === "object" && (resource as { uri?: unknown }).uri === read.uri
+  );
+  if (matching.length !== 1) throw new Error("invalid_manifest: MCP resource URI must resolve exactly once");
+  const observation = emptyObservation();
+  setClientResponse(observation, {
+    json: {
+      resources: decoded.resources,
+      contents: read.contents,
+    },
+    status: 200,
+  });
+  return observation;
+}
+
+export function attachMcpVerifiers(observation: NormalizedObservation, caseRecord: CaseRecord): void {
+  if (caseRecord.id === "mcp-core.protocol.namespace-mapping") {
+    const toolCalls = observation.client.response.toolCalls;
+    if (toolCalls.length === 1) {
+      observation.client.response.mcpCalls = projectMcpCalls(toolCalls);
+    }
+  }
+  // runCallResult records the literal one-invocation receipt. Do not reconstruct it here:
+  // assertions must inspect the action result that actually ran.
+}

package/src/lab/conformance/negative-controls.ts

@@ -0,0 +1,164 @@
+import type { CaseRecord } from "./types";
+
+/** Deliberately broken variants proving the harness rejects known defects. */
+export const NEGATIVE_CONTROL_FIXTURES: Array<{
+  id: string;
+  defect: string;
+  mutate: (caseRecord: CaseRecord) => CaseRecord;
+}> = [
+  {
+    id: "negative.malformed-sse",
+    defect: "malformed SSE JSON",
+    mutate: (c) => ({
+      ...c,
+      id: "negative.malformed-sse",
+      assertions: [
+        { id: "events", operator: "sse_event_sequence", selector: "/client/response/events", expected: ["response.completed"], required: true },
+        { id: "terminal", operator: "terminal_signal_equals", selector: "/client/response/terminal", expected: "completed", required: true },
+      ],
+      fixture: {
+        ...c.fixture,
+        bytesUtf8: "data: {not-json}\n\ndata: {\"type\":\"response.completed\",\"response\":{\"status\":\"completed\"}}\n\n",
+      },
+    }),
+  },
+  {
+    id: "negative.missing-terminal",
+    defect: "missing terminal event",
+    mutate: (c) => ({
+      ...c,
+      id: "negative.missing-terminal",
+      assertions: [{ id: "terminal", operator: "terminal_signal_equals", selector: "/client/response/terminal", expected: "completed", required: true }],
+      fixture: {
+        ...c.fixture,
+        bytesUtf8: "data: {\"type\":\"response.output_text.delta\",\"delta\":\"A\"}\n\n",
+      },
+    }),
+  },
+  {
+    id: "negative.corrupted-tool-id",
+    defect: "corrupted tool IDs",
+    mutate: (c) => ({
+      ...c,
+      id: "negative.corrupted-tool-id",
+      assertions: [{ id: "alpha", operator: "tool_call_equals", selector: "/client/response/toolCalls/0", expected: { id: "call_a", name: "alpha", arguments: { x: 1 }, kind: "function", ordinal: 0 }, required: true }],
+      fixture: {
+        ...c.fixture,
+        bytesUtf8: "data:{\"choices\":[{\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"WRONG\",\"function\":{\"name\":\"alpha\",\"arguments\":\"{\\\"x\\\":1}\"}}]}}]}\n\ndata:{\"choices\":[{\"finish_reason\":\"tool_calls\"}]}\n\ndata:[DONE]\n\n",
+      },
+    }),
+  },
+  {
+    id: "negative.tool-result-order",
+    defect: "invalid tool-result correlation after chat-history repair",
+    mutate: (c) => ({
+      ...c,
+      id: "negative.tool-result-order",
+      // Chat history hardening closes the unmatched call with a synthetic result, then
+      // re-emits the orphan result behind a synthetic assistant call. Inspect the actual
+      // supplied result at the end of that repaired pair rather than the synthetic close,
+      // otherwise the negative control accidentally validates the repair and passes.
+      assertions: [{ id: "result", operator: "tool_result_correlates", selector: "/upstream/requests", expected: { call: "/client/response/toolCalls/0/id", result: "/upstream/requests/1/json/messages/3/tool_call_id" }, required: true }],
+      fixture: {
+        ...c.fixture,
+        bytesUtf8: JSON.stringify({
+          tools: [{ name: "lookup", parameters: { type: "object", properties: { q: { type: "string" } }, required: ["q"] } }],
+          upstreamToolCall: { id: "call_fixture", name: "lookup", arguments: "{\"q\":\"x\"}" },
+          toolResult: { toolCallId: "wrong_id", content: "RESULT" },
+        }),
+      },
+    }),
+  },
+  {
+    id: "negative.truncated-tool-args",
+    defect: "truncated tool arguments",
+    mutate: (c) => ({
+      ...c,
+      id: "negative.truncated-tool-args",
+      assertions: [{ id: "alpha", operator: "tool_call_equals", selector: "/client/response/toolCalls/0", expected: { id: "call_a", name: "alpha", arguments: { x: 1 }, kind: "function", ordinal: 0 }, required: true }],
+      fixture: {
+        ...c.fixture,
+        bytesUtf8: `data: ${JSON.stringify({ choices: [{ delta: { tool_calls: [{ index: 0, id: "call_a", function: { name: "alpha", arguments: "{\"x\":" } }] } }] })}\n\ndata: ${JSON.stringify({ choices: [{ finish_reason: "tool_calls" }] })}\n\ndata: [DONE]\n\n`,
+      },
+    }),
+  },
+  {
+    id: "negative.parallel-tool-fragments",
+    defect: "duplicate parallel-tool fragments",
+    mutate: (c) => ({
+      ...c,
+      id: "negative.parallel-tool-fragments",
+      assertions: [{ id: "order", operator: "json_path_equals", selector: "/verifiers/nonoverlap_order", expected: ["call_a", "call_b"], required: true }],
+      fixture: {
+        ...c.fixture,
+        bytesUtf8: "data:{\"choices\":[{\"delta\":{\"tool_calls\":[{\"index\":0,\"id\":\"call_a\",\"function\":{\"name\":\"a\",\"arguments\":\"{}\"}},{\"index\":0,\"id\":\"call_a\",\"function\":{\"name\":\"a\",\"arguments\":\"{}\"}}]}}]}\n\ndata:{\"choices\":[{\"finish_reason\":\"tool_calls\"}]}\n\ndata:[DONE]\n\n",
+      },
+    }),
+  },
+  {
+    id: "negative.custom-tool-failure",
+    defect: "custom/freeform tool translation failure",
+    mutate: (c) => ({
+      ...c,
+      id: "negative.custom-tool-failure",
+      assertions: [{ id: "call", operator: "tool_call_equals", selector: "/client/response/toolCalls/0", expected: { id: "call_patch", name: "apply_patch", arguments: "*** Begin Patch\n*** End Patch\n", kind: "custom", ordinal: 0 }, required: true }],
+      fixture: {
+        ...c.fixture,
+        bytesUtf8: JSON.stringify({
+          tool: { type: "custom", name: "apply_patch", format: { type: "grammar", syntax: "lark", definition: "start: /[\\s\\S]+/" } },
+          call: { id: "call_patch", name: "apply_patch", input: "WRONG PATCH" },
+          output: { call_id: "call_patch", output: "Done" },
+        }),
+      },
+    }),
+  },
+  {
+    id: "negative.continuation-semantics",
+    defect: "invalid continuation semantics",
+    mutate: (c) => ({
+      ...c,
+      id: "negative.continuation-semantics",
+      assertions: [{ id: "order", operator: "json_path_equals", selector: "/verifiers/call_result_order", expected: "pass", required: true }],
+      fixture: {
+        ...c.fixture,
+        bytesUtf8: JSON.stringify({
+          turn1: { output: [{ type: "function_call", id: "fc_fixture", call_id: "call_fixture", name: "lookup", arguments: "{}" }] },
+          turn2: { input: [{ type: "function_call_output", call_id: "wrong_call", output: "RESULT" }] },
+        }),
+      },
+    }),
+  },
+];
+
+export function baseCaseForNegativeControl(controlId: string, cases: CaseRecord[]): CaseRecord | undefined {
+  switch (controlId) {
+    case "negative.malformed-sse":
+    case "negative.missing-terminal":
+      return cases.find((c) => c.id === "responses-core.protocol.sse-framing");
+    case "negative.corrupted-tool-id":
+    case "negative.truncated-tool-args":
+      return cases.find((c) => c.id === "chat-core.protocol.stream-assembly");
+    case "negative.tool-result-order":
+      return cases.find((c) => c.id === "tools-core.protocol.function-round-trip");
+    case "negative.parallel-tool-fragments":
+      return cases.find((c) => c.id === "tools-core.protocol.parallel-correlation");
+    case "negative.custom-tool-failure":
+      return cases.find((c) => c.id === "tools-core.protocol.custom-freeform-round-trip");
+    case "negative.continuation-semantics":
+      return cases.find((c) => c.id === "codex-core.protocol.tool-continuation");
+    default:
+      return undefined;
+  }
+}
+
+export function buildNegativeControls(cases: CaseRecord[]): CaseRecord[] {
+  const built: CaseRecord[] = [];
+  for (const control of NEGATIVE_CONTROL_FIXTURES) {
+    const base = baseCaseForNegativeControl(control.id, cases);
+    if (!base) continue;
+    const cloned = structuredClone(base);
+    delete cloned.expectedFailure;
+    built.push(control.mutate(cloned));
+  }
+  return built;
+}