feat: execute WP7-02 independent model matrices

tests/integration/wp7-02-controlled-state.test.ts

@@ -0,0 +1,151 @@
+import { createHash, randomUUID } from "node:crypto";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+
+import { describe, expect, it } from "vitest";
+
+import { CreditService } from "../../apps/api/src/credits.js";
+import { ModelConfigurationService, modelIds, type ModelConfigCandidate } from "../../apps/api/src/model-configuration.js";
+import { ModelContractEvidenceService } from "../../apps/api/src/model-contract-evidence.js";
+import { ProjectService } from "../../apps/api/src/projects.js";
+import { RegistrationService } from "../../apps/api/src/registration.js";
+import { MockResendAdapter } from "../../apps/api/src/resend-adapter.js";
+import { settleGenerationCredits } from "../../apps/worker/src/credit-settlement.js";
+import { generationErrorCategories, generationErrorRegistry } from "../../apps/worker/src/generation-error-registry.js";
+
+const now = Date.parse("2026-08-04T08:00:00.000Z");
+
+function matrix(modelId: string) {
+  return {
+    error_mapping: [...generationErrorCategories],
+    execution_modes: ["sync", "async", "poll"],
+    model_id: modelId,
+    pure_text: { outputs: 1, status: "passed" },
+    ratios: ["3:4", "1:1", "4:3", "9:16"].map((ratio) => ({ outputs: 1, ratio, status: "passed" })),
+    reference_image: { outputs: 1, status: "passed" },
+  };
+}
+
+function editable(models: ReturnType<ModelConfigurationService["read"]>["models"]): ModelConfigCandidate[] {
+  return models.map(({ config_version: _version, runtime_availability: _runtime, ...candidate }) => structuredClone(candidate));
+}
+
+function writeModelEvidence(modelId: string, value: unknown) {
+  const root = process.env.DADA_WP7_02_STATE_EVIDENCE_ROOT;
+  if (!root) return;
+  const directory = resolve(root, modelId.replaceAll(".", "_"));
+  mkdirSync(directory, { recursive: true });
+  writeFileSync(resolve(directory, "deterministic-state.json"), `${JSON.stringify(value, null, 2)}\n`);
+}
+
+describe("TDD-WP7-EXT-001 controlled deterministic state boundaries", () => {
+  it("proves nine errors, settlement replay, invalidation and full revalidation independently per model", () => {
+    const evidenceIds = new Set<string>();
+    for (const modelId of modelIds) {
+      const root = mkdtempSync(join(tmpdir(), "dada-wp7-02-state-"));
+      const databasePath = join(root, "dada.sqlite3");
+      const registration = new RegistrationService({
+        challengePepper: Buffer.alloc(32, 0xd1), clock: () => now,
+        currentPrivacyNoticeVersion: "p0a-registration-notice-v1", databasePath,
+        invitePepper: Buffer.alloc(32, 0xd2), resend: new MockResendAdapter(), sessionPepper: Buffer.alloc(32, 0xd3),
+      });
+      const projects = new ProjectService({ clock: () => now, databasePath });
+      let credits = new CreditService({ clock: () => now, databasePath });
+      try {
+        const settlements = [];
+        for (const outcome of ["succeeded", "failed", "rejected"] as const) {
+          const userId = randomUUID();
+          registration.database.prepare(`INSERT INTO users (
+            user_id, normalized_email, role, status, counts_toward_stage_limit, registration_id, created_at
+          ) VALUES (?, ?, 'user', 'active', 1, ?, ?)`).run(userId, `${userId}@example.invalid`, randomUUID(), now);
+          registration.database.prepare("INSERT INTO user_profiles (user_id, creator_name, social_id) VALUES (?, 'WP7 User', '@wp7')").run(userId);
+          registration.database.prepare("INSERT INTO credit_accounts (user_id, available_balance, reserved_balance, updated_at) VALUES (?, 1, 0, ?)").run(userId, now);
+          const generationId = projects.createProjectForGeneration({ ownerId: userId, prompt: "controlled fixture", ratio: "1:1", status: "queued" }).generation.generationId;
+          credits.reserveGeneration({ creditCost: 1, generationId, modelId, operationKey: `generation:${generationId}:reserve`, userId });
+          const input = { generationId, operationKey: `generation:${generationId}:finalize`, outcome };
+          const first = settleGenerationCredits(credits, input);
+          const replay = settleGenerationCredits(credits, input);
+          credits.close();
+          credits = new CreditService({ clock: () => now, databasePath });
+          const restartReplay = settleGenerationCredits(credits, input);
+          expect(replay).toEqual(first);
+          expect(restartReplay).toEqual(first);
+          const account = credits.readAccount(userId);
+          const ledger = registration.database.prepare(`SELECT entry_type, COUNT(*) AS count FROM credit_ledger
+            WHERE user_id = ? AND entry_type IN ('generation_commit', 'generation_release') GROUP BY entry_type`).get(userId);
+          expect(account).toMatchObject({ availableBalance: outcome === "succeeded" ? 0 : 1, reservedBalance: 0 });
+          expect(ledger).toEqual({ count: 1, entry_type: outcome === "succeeded" ? "generation_commit" : "generation_release" });
+          settlements.push({
+            available_after: account.availableBalance,
+            ledger_entries: 1,
+            outcome,
+            reserved_after: account.reservedBalance,
+            replay_count: 2,
+          });
+        }
+
+        const models = new ModelConfigurationService({ clock: () => now, database: registration.database });
+        const contracts = new ModelContractEvidenceService({ clock: () => now, database: registration.database, models });
+        const firstEvidenceHash = `sha256:${createHash("sha256").update(`${modelId}:v1`).digest("hex")}`;
+        const first = contracts.recordVerified({
+          actorId: "wp7-02-controlled", expectedConfigSetVersion: 1,
+          evidence: {
+            evidence_hash: firstEvidenceHash,
+            evidence_ref: `wp7-02:${modelId}:first`,
+            matrix: matrix(modelId), model_id: modelId,
+            verified_at: new Date(now).toISOString(), verifier_ref: "wp7-02-controlled",
+          },
+          idempotencyKey: `wp7-02:${modelId}:first`,
+        });
+        expect(first.model.contract_validation_status).toBe("verified");
+        const candidates = editable(first.configuration.models);
+        const target = candidates.find((candidate) => candidate.model_id === modelId)!;
+        target.route_profile = { ...target.route_profile, contract_revision: 2 };
+        const changed = models.replace({
+          actorId: "wp7-02-controlled", expectedConfigSetVersion: 2,
+          idempotencyKey: `wp7-02:${modelId}:change`, models: candidates,
+        });
+        const invalidated = changed.models.find((model) => model.model_id === modelId)!;
+        expect(invalidated.contract_validation_status).toBe("unverified");
+        const secondEvidenceHash = `sha256:${createHash("sha256").update(`${modelId}:v2`).digest("hex")}`;
+        const revalidated = contracts.recordVerified({
+          actorId: "wp7-02-controlled", expectedConfigSetVersion: 3,
+          evidence: {
+            evidence_hash: secondEvidenceHash,
+            evidence_ref: `wp7-02:${modelId}:second`,
+            matrix: matrix(modelId), model_id: modelId,
+            verified_at: new Date(now + 1_000).toISOString(), verifier_ref: "wp7-02-controlled",
+          },
+          idempotencyKey: `wp7-02:${modelId}:second`,
+        });
+        expect(revalidated.model.contract_validation_status).toBe("verified");
+        expect(contracts.read(modelId, first.model.config_version)?.evidence_hash).toBe(firstEvidenceHash);
+        expect(contracts.read(modelId, revalidated.model.config_version)?.evidence_hash).toBe(secondEvidenceHash);
+
+        const evidenceId = `sha256:${createHash("sha256").update(`${modelId}:deterministic-state`).digest("hex")}`;
+        expect(evidenceIds.has(evidenceId)).toBe(false);
+        evidenceIds.add(evidenceId);
+        writeModelEvidence(modelId, {
+          contract_change: {
+            after_change: { config_set_version: 3, config_version: invalidated.config_version, status: invalidated.contract_validation_status },
+            after_revalidation: { config_set_version: 4, config_version: revalidated.model.config_version, status: revalidated.model.contract_validation_status },
+            before_change: { config_set_version: 2, config_version: first.model.config_version, status: first.model.contract_validation_status },
+            full_matrix_reapplied: true,
+          },
+          error_scenarios: generationErrorCategories.map((category) => ({ category, ...generationErrorRegistry[category], source: "deterministic_local", status: "passed" })),
+          evidence_id: evidenceId,
+          model_id: modelId,
+          settlements,
+          status: "passed",
+        });
+      } finally {
+        credits.close();
+        projects.close();
+        registration.close();
+        rmSync(root, { force: true, recursive: true });
+      }
+    }
+    expect(evidenceIds.size).toBe(3);
+  });
+});

tests/package/wp7-02-controlled-executor.test.mjs

@@ -10,6 +10,12 @@ import {
   normalizeProviderResponse,
   validateSanitizedEvidence,
 } from "../../scripts/lib/wp7-02-controlled-executor.mjs";
+import {
+  assembleControlledModelEvidence,
+  buildDeterministicExecutionEvidence,
+  createControlledReferencePng,
+  runControlledRealScenarios,
+} from "../../scripts/lib/wp7-02-controlled-matrix.mjs";
 
 const models = [
   {
@@ -82,7 +88,7 @@ test("TDD-WP7-EXT-001 builds protocol-specific requests without auth in argument
     model: "gpt-image-2",
     prompt: "controlled fixture prompt",
     response_format: "b64_json",
-    size: "1024x1536",
+    size: "1080x1920",
   });
   assert.equal("authorization" in openai.headers, false);
 });
@@ -138,3 +144,65 @@ test("TDD-WP7-EXT-001 confines the credential to the request header and discards
     return true;
   });
 });
+
+test("TDD-WP7-EXT-001 executes only five real success probes per model and keeps failed ratios blocking", async () => {
+  let fetchCalls = 0;
+  const execution = await runControlledRealScenarios({
+    fetchImpl: async () => {
+      fetchCalls += 1;
+      return new Response(JSON.stringify({
+        candidates: [{ content: { parts: [{ inlineData: { data: onePixelPng.toString("base64"), mimeType: "image/png" } }] } }],
+      }), { status: 200 });
+    },
+    maxRealCalls: 120,
+    modelConfig: models[0],
+    token: "controlled-secret-value-for-test-only",
+  });
+  assert.equal(fetchCalls, 5);
+  assert.equal(execution.real_calls, 5);
+  assert.equal(execution.status, "externally_blocked");
+  assert.equal(execution.calls.filter((call) => call.status === "passed").length, 2);
+  assert.doesNotMatch(JSON.stringify(execution), /controlled-secret|fixture prompt|iVBOR/i);
+  await assert.rejects(() => runControlledRealScenarios({ maxRealCalls: 121, modelConfig: models[0], token: "not-used" }), /WP7_02_REAL_CALL_LIMIT_INVALID/);
+});
+
+test("TDD-WP7-EXT-001 assembles independent complete evidence without retaining reference bytes", () => {
+  const reference = createControlledReferencePng();
+  assert.equal(reference.subarray(0, 8).toString("hex"), "89504e470d0a1a0a");
+  const calls = ["3:4", "1:1", "4:3", "9:16"].map((ratio, index) => ({
+    duration_ms: 1,
+    http_status: 200,
+    input: "pure_text",
+    requested_ratio: ratio,
+    response: { dimensions: { height: 1, width: 1 }, evidence_hash: `sha256:${"A".repeat(64)}`, mime: "image/png", usage_summary: { input_units: 0, output_units: 0, total_units: 0 } },
+    scenario_id: `real-${index + 1}`,
+    source: "real_gateway",
+    status: "passed",
+  }));
+  calls.push({ ...calls[1], input: "reference_image", scenario_id: "real-5" });
+  const deterministicState = {
+    contract_change: { full_matrix_reapplied: true },
+    error_scenarios: Array.from({ length: 9 }, (_, index) => ({ category: `category-${index}`, status: "passed" })),
+    model_id: models[0].model_id,
+    settlements: ["succeeded", "failed", "rejected"].map((outcome) => ({ outcome })),
+    status: "passed",
+  };
+  const evidence = assembleControlledModelEvidence({
+    deterministicState,
+    modelConfig: models[0],
+    realExecution: { calls, planned_real_calls: 5, real_calls: 5, status: "passed" },
+    runId: "wp7-02-assembly-test",
+  });
+  assert.equal(evidence.status, "passed");
+  assert.equal(evidence.manual_review.status, "pending");
+  assert.equal(evidence.matrix.error_scenarios.length, 9);
+  assert.doesNotMatch(JSON.stringify(evidence), /iVBOR|image_bytes|raw_prompt|authorization/i);
+  const execution = buildDeterministicExecutionEvidence(models[0].model_id, "wp7-02-assembly-test");
+  assert.deepEqual(execution.modes.map((entry) => entry.mode), ["sync", "async", "poll"]);
+  assert.deepEqual(execution.trace.map((entry) => `${entry.action}:${entry.before}->${entry.after}`), [
+    "start:created->pending",
+    "poll:pending->completed",
+    "poll:completed->completed",
+  ]);
+  assert.equal(execution.trace[2].replay, true);
+});