Merge pull request 'feat(P0-A): 整合第一版并冻结最终发布' (#1) from codex/wp7-07 into codex/wp0-09

Reviewed-on: #1

RELEASE.json

@@ -0,0 +1,29 @@
+{
+  "appVersion": "0.0.0",
+  "browsers": [
+    {
+      "brand": "Google Chrome",
+      "fullVersion": "150.0.7871.187"
+    },
+    {
+      "brand": "Microsoft Edge",
+      "fullVersion": "151.0.4129.59"
+    }
+  ],
+  "buildCommit": "08f3cccae4a1e75e2f2292eef14611313523916d",
+  "deferredExternalTasks": [
+    "TASK-WP7-03",
+    "TASK-WP7-04"
+  ],
+  "finalRelease": true,
+  "fixedPort": 43121,
+  "frozenFromCommit": "08e9c39e49d68f8642d5acfe22b0fdb40a3a08fa",
+  "recordedAt": "2026-08-04T15:20:54.271Z",
+  "releaseStatus": "first_version_internal",
+  "schemaVersion": "1.0",
+  "windows": {
+    "arch": "x64",
+    "build": "26200.8875",
+    "displayVersion": "25H2"
+  }
+}

apps/api/src/amap-adapter.ts

@@ -1,5 +1,31 @@
+import { request as httpsRequest } from "node:https";
+
+const amapHostname = "restapi.amap.com" as const;
+const amapMaxResponseBytes = 65_536;
+const amapTimeoutMs = 15_000;
+
+export interface AmapHttpRequest {
+  allowRedirects: false;
+  hostname: typeof amapHostname;
+  maxResponseBytes: number;
+  method: "GET";
+  path: string;
+  protocol: "https:";
+  rejectUnauthorized: true;
+  timeoutMs: number;
+}
+
+type AmapRequester = (request: AmapHttpRequest) => Promise<unknown>;
+
+export class AmapAdapterError extends Error {
+  constructor(readonly code: "amap_adapter_disposed" | "amap_invalid_request" | "amap_invalid_response" | "amap_provider_rejected" | "amap_provider_unavailable" | "amap_redirect_rejected" | "amap_request_timeout" | "amap_response_too_large") {
+    super(code);
+  }
+}
+
 export interface AmapAdapter {
-  reverseGeocode(coordinates: { latitude: number; longitude: number }): Promise<{ formattedValue: string; serviceMode: "mock" }>;
+  dispose?(): void;
+  reverseGeocode(coordinates: { latitude: number; longitude: number }): Promise<{ formattedValue: string; serviceMode: "mock" | "real" }>;
 }
 
 export class MockAmapAdapter implements AmapAdapter {
@@ -13,3 +39,126 @@ export class MockAmapAdapter implements AmapAdapter {
     };
   }
 }
+
+function requestAmapJson(input: AmapHttpRequest) {
+  return new Promise<unknown>((resolve, reject) => {
+    if (input.protocol !== "https:" || input.hostname !== amapHostname || input.allowRedirects || !input.rejectUnauthorized) {
+      reject(new AmapAdapterError("amap_invalid_request"));
+      return;
+    }
+    let settled = false;
+    const finish = (callback: () => void) => {
+      if (settled) return;
+      settled = true;
+      callback();
+    };
+    const request = httpsRequest({
+      headers: { Accept: "application/json" },
+      hostname: input.hostname,
+      method: input.method,
+      path: input.path,
+      port: 443,
+      protocol: input.protocol,
+      rejectUnauthorized: input.rejectUnauthorized,
+      servername: input.hostname,
+    }, (response) => {
+      const statusCode = response.statusCode ?? 0;
+      if (statusCode >= 300 && statusCode < 400) {
+        response.resume();
+        finish(() => reject(new AmapAdapterError("amap_redirect_rejected")));
+        return;
+      }
+      if (statusCode !== 200) {
+        response.resume();
+        finish(() => reject(new AmapAdapterError("amap_provider_unavailable")));
+        return;
+      }
+      const declaredLength = Number(response.headers["content-length"] ?? 0);
+      if (Number.isFinite(declaredLength) && declaredLength > input.maxResponseBytes) {
+        response.destroy();
+        finish(() => reject(new AmapAdapterError("amap_response_too_large")));
+        return;
+      }
+      const chunks: Buffer[] = [];
+      let receivedBytes = 0;
+      response.on("data", (chunk: Buffer | string) => {
+        const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        receivedBytes += bytes.length;
+        if (receivedBytes > input.maxResponseBytes) {
+          response.destroy();
+          finish(() => reject(new AmapAdapterError("amap_response_too_large")));
+          return;
+        }
+        chunks.push(bytes);
+      });
+      response.on("end", () => {
+        finish(() => {
+          try {
+            resolve(JSON.parse(Buffer.concat(chunks).toString("utf8")));
+          } catch {
+            reject(new AmapAdapterError("amap_invalid_response"));
+          } finally {
+            for (const chunk of chunks) chunk.fill(0);
+            chunks.length = 0;
+          }
+        });
+      });
+    });
+    request.setTimeout(input.timeoutMs, () => request.destroy(new AmapAdapterError("amap_request_timeout")));
+    request.on("error", (error) => finish(() => reject(error instanceof AmapAdapterError ? error : new AmapAdapterError("amap_provider_unavailable"))));
+    request.end();
+  });
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+export class RealAmapAdapter implements AmapAdapter {
+  private readonly credential: Buffer;
+  private readonly requester: AmapRequester;
+  private disposed = false;
+
+  constructor(value: string, options: { request?: AmapRequester } = {}) {
+    if (!value.trim()) throw new AmapAdapterError("amap_invalid_request");
+    this.credential = Buffer.from(value, "utf8");
+    this.requester = options.request ?? requestAmapJson;
+  }
+
+  async reverseGeocode(coordinates: { latitude: number; longitude: number }) {
+    if (this.disposed) throw new AmapAdapterError("amap_adapter_disposed");
+    if (!Number.isFinite(coordinates.latitude) || coordinates.latitude < -90 || coordinates.latitude > 90
+      || !Number.isFinite(coordinates.longitude) || coordinates.longitude < -180 || coordinates.longitude > 180) {
+      throw new AmapAdapterError("amap_invalid_request");
+    }
+    const query = new URLSearchParams({
+      extensions: "base",
+      key: this.credential.toString("utf8"),
+      location: `${coordinates.longitude},${coordinates.latitude}`,
+    });
+    const response = await this.requester({
+      allowRedirects: false,
+      hostname: amapHostname,
+      maxResponseBytes: amapMaxResponseBytes,
+      method: "GET",
+      path: `/v3/geocode/regeo?${query.toString()}`,
+      protocol: "https:",
+      rejectUnauthorized: true,
+      timeoutMs: amapTimeoutMs,
+    });
+    if (!isRecord(response) || response.status !== "1" || !isRecord(response.regeocode)) {
+      throw new AmapAdapterError("amap_provider_rejected");
+    }
+    const formattedValue = typeof response.regeocode.formatted_address === "string"
+      ? response.regeocode.formatted_address.trim()
+      : "";
+    if (!formattedValue || formattedValue.length > 200) throw new AmapAdapterError("amap_invalid_response");
+    return { formattedValue, serviceMode: "real" as const };
+  }
+
+  dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.credential.fill(0);
+  }
+}

apps/api/src/main.ts

@@ -17,7 +17,7 @@ import { readSecureConfigCandidate } from "./secure-config.js";
 import { StructuredJsonlLogger } from "./structured-log.js";
 import { attachApiSupervisorControl, initializeApiCredentialClients, receiveApiCredentials } from "./supervisor-channel.js";
 import { ModelConfigurationService } from "./model-configuration.js";
-import { MockAmapAdapter } from "./amap-adapter.js";
+import { MockAmapAdapter, type AmapAdapter } from "./amap-adapter.js";
 import { StickerReleaseService } from "./sticker-releases.js";
 import { createAdminDiagnosticsProvider, createAdminServicesStorageProvider } from "./admin-state.js";
 
@@ -30,10 +30,12 @@ let latestExports: LatestExportService | undefined;
 let models: ModelConfigurationService | undefined;
 let recentAssets: RecentAssetService | undefined;
 let stickers: StickerReleaseService | undefined;
+let amap: AmapAdapter = new MockAmapAdapter();
 const instanceConfigPath = process.env.DADA_INSTANCE_CONFIG_PATH ?? defaultInstanceConfigPath();
 if (credentialChannelEnabled) {
   const clients = initializeApiCredentialClients(await receiveApiCredentials());
   try {
+    amap = clients.amap;
     const derivePepper = (purpose: string) => createHmac("sha256", clients.adminAllowlistPepper)
       .update(`Dada/P0A/${purpose}/v1`, "utf8")
       .digest();
@@ -57,6 +59,8 @@ if (credentialChannelEnabled) {
     recentAssets = new RecentAssetService({ database: registration.database });
     registration.applySecureConfig(readSecureConfigCandidate(instanceConfigPath));
   } catch (error) {
+    amap.dispose?.();
+    amap = new MockAmapAdapter();
     stickers?.close();
     stickers = undefined;
     latestExports?.close();
@@ -92,7 +96,7 @@ const adminDiagnostics = adminServicesStorage
 const app = await createApp({
   ...(adminServicesStorage ? { adminServicesStorage } : {}),
   ...(adminDiagnostics ? { adminDiagnostics } : {}),
-  amap: new MockAmapAdapter(),
+  amap,
   ...(browserSupportRelease ? { browserSupportRelease } : {}),
   ...(credits ? { credits } : {}),
   ...(latestExports ? { latestExports } : {}),
@@ -115,6 +119,7 @@ if (controlPipeIndex >= 0) {
   if (!controlPipe) throw new Error("Supervisor control pipe name is required.");
   const control = attachApiSupervisorControl(controlPipe, async () => {
     await app.close();
+    amap.dispose?.();
     latestExports?.close();
     credits?.close();
     projects?.close();

apps/api/src/supervisor-channel.ts

@@ -1,5 +1,7 @@
 import { createConnection } from "node:net";
 
+import { RealAmapAdapter } from "./amap-adapter.js";
+
 const API_CREDENTIALS = ["Dada/P0A/api/resend", "Dada/P0A/api/amap", "Dada/P0A/admin/pepper"] as const;
 
 export async function receiveApiCredentials(input: NodeJS.ReadableStream = process.stdin) {
@@ -26,10 +28,15 @@ export async function receiveApiCredentials(input: NodeJS.ReadableStream = proce
 
 export function initializeApiCredentialClients(credentials: Record<(typeof API_CREDENTIALS)[number], string>) {
   const configured = API_CREDENTIALS.every((name) => credentials[name].length > 0);
-  const adminPepperValue = credentials["Dada/P0A/admin/pepper"];
-  for (const name of API_CREDENTIALS) credentials[name] = "";
-  if (!configured) throw new Error("API credential client initialization failed.");
-  return { adminAllowlistPepper: Buffer.from(adminPepperValue, "utf8") };
+  try {
+    if (!configured) throw new Error("API credential client initialization failed.");
+    return {
+      adminAllowlistPepper: Buffer.from(credentials["Dada/P0A/admin/pepper"], "utf8"),
+      amap: new RealAmapAdapter(credentials["Dada/P0A/api/amap"]),
+    };
+  } finally {
+    for (const name of API_CREDENTIALS) credentials[name] = "";
+  }
 }
 
 export function attachApiSupervisorControl(pipeName: string, shutdown: () => Promise<void>) {

apps/web/src/generated/api/types.gen.ts

@@ -922,7 +922,7 @@ export type ReverseGeocodeRequest = {
 
 export type ReverseGeocodeResponse = {
   "formatted_value": string;
-  "service_mode": "mock";
+  "service_mode": "mock" | "real";
   "status": "resolved";
 };
 

openapi/openapi.json

@@ -5621,10 +5621,20 @@
             "type": "string"
           },
           "service_mode": {
-            "enum": [
-              "mock"
-            ],
-            "type": "string"
+            "anyOf": [
+              {
+                "enum": [
+                  "mock"
+                ],
+                "type": "string"
+              },
+              {
+                "enum": [
+                  "real"
+                ],
+                "type": "string"
+              }
+            ]
           },
           "status": {
             "enum": [

package.json

@@ -109,7 +109,16 @@
     "review:wp7-01": "node scripts/record-wp7-01-manual-review.mjs",
     "test:wp7-02": "node scripts/run-wp7-02-validation.mjs",
     "test:wp7-02:controlled": "node scripts/run-wp7-02-validation.mjs --controlled-real",
-    "review:wp7-02": "node scripts/record-wp7-02-manual-review.mjs"
+    "review:wp7-02": "node scripts/record-wp7-02-manual-review.mjs",
+    "test:wp7-03": "node scripts/run-wp7-03-validation.mjs --phase green",
+    "test:wp7-03:red": "node scripts/run-wp7-03-validation.mjs --phase red",
+    "test:wp7-04": "node scripts/run-wp7-04-validation.mjs",
+    "test:wp7-05": "node scripts/run-wp7-05-validation.mjs",
+    "test:wp7-05:unit": "node --test tests/package/wp7-05-ui-gate.test.mjs tests/package/wp7-05-coverage.test.mjs",
+    "test:wp7-06": "node scripts/run-wp7-06-validation.mjs",
+    "test:wp7-06:unit": "node --test tests/package/wp7-06-prefreeze.test.mjs",
+    "test:wp7-07": "node scripts/run-wp7-07-validation.mjs",
+    "test:wp7-07:unit": "node --test tests/package/wp7-07-final-release.test.mjs"
   },
   "devDependencies": {
     "@playwright/test": "1.62.0",

packages/shared-contracts/src/location.ts

@@ -7,7 +7,7 @@ export const ReverseGeocodeRequestSchema = Type.Object({
 
 export const ReverseGeocodeResponseSchema = Type.Object({
   formatted_value: Type.String({ maxLength: 200, minLength: 1 }),
-  service_mode: Type.Literal("mock"),
+  service_mode: Type.Union([Type.Literal("mock"), Type.Literal("real")]),
   status: Type.Literal("resolved"),
 }, { additionalProperties: false, $id: "ReverseGeocodeResponse" });
 

scripts/lib/portable-package.mjs

@@ -165,7 +165,7 @@ function copyApplication(source, destination, runtimeDependencies) {
 
 function buildArtifacts(stagingRoot) {
   debug("build workspace artifacts");
-  run("pnpm", ["--filter", "@dada/shared-contracts", "build"]);
+  run("pnpm", ["build:workspace-packages"]);
   run("pnpm", ["--filter", "@dada/web", "build"]);
   run("pnpm", ["--filter", "@dada/api", "build"]);
   run("pnpm", ["--filter", "@dada/worker", "build"]);
@@ -208,7 +208,7 @@ async function waitForHealth(child) {
   throw new Error("Packaged API did not become healthy on fixed port 43121.", { cause: lastError });
 }
 
-async function verifyExtractedPackage(zipPath, packageName) {
+export async function verifyExtractedPackage(zipPath, packageName, expectedSupport) {
   const extractRoot = mkdtempSync(join(tmpdir(), "dada-wp0-09-"));
   try {
     const escapedZip = zipPath.replaceAll("'", "''");
@@ -235,21 +235,37 @@ async function verifyExtractedPackage(zipPath, packageName) {
     });
     try {
       const health = await waitForHealth(api);
+      const brands = [
+        { brand: "Not_A Brand", version: "99" },
+        { brand: "Chromium", version: String(expectedSupport.major) },
+        { brand: expectedSupport.brand, version: String(expectedSupport.major) },
+      ];
+      const fullVersionList = [
+        { brand: "Not_A Brand", version: "99.0.0.0" },
+        { brand: "Chromium", version: expectedSupport.fullVersion },
+        { brand: expectedSupport.brand, version: expectedSupport.fullVersion },
+      ];
+      const serializeBrands = (values) => values.map(({ brand, version }) => `"${brand}";v="${version}"`).join(", ");
       const releaseGate = await fetch(`http://127.0.0.1:${fixedPort}/api/v1/support/check`, {
         body: JSON.stringify({
-          brands: [{ brand: "Google Chrome", version: "150" }],
-          full_version_list: [{ brand: "Google Chrome", version: "150.0.0.0" }],
+          brands,
+          full_version_list: fullVersionList,
           platform: "Windows",
         }),
         headers: {
           "content-type": "application/json",
-          "sec-ch-ua": '"Google Chrome";v="150"',
-          "sec-ch-ua-full-version-list": '"Google Chrome";v="150.0.0.0"',
+          host: `127.0.0.1:${fixedPort}`,
+          origin: `http://127.0.0.1:${fixedPort}`,
+          "sec-ch-ua": serializeBrands(brands),
+          "sec-ch-ua-full-version-list": serializeBrands(fullVersionList),
           "sec-ch-ua-platform": '"Windows"',
         },
         method: "POST",
       });
-      if (releaseGate.status !== 426) throw new Error(`Candidate RELEASE.json unexpectedly passed with ${releaseGate.status}.`);
+      if (releaseGate.status !== expectedSupport.statusCode) {
+        const responseBody = await releaseGate.text();
+        throw new Error(`Packaged RELEASE.json support gate returned ${releaseGate.status}; expected ${expectedSupport.statusCode}: ${responseBody}`);
+      }
       return {
         api: { executable: "runtime/node.exe", health, pid: api.pid, release_gate: { status_code: releaseGate.status }, status: "passed" },
         native,
@@ -291,7 +307,7 @@ function scanPackage(packageDirectory) {
   return { disallowed_matches: disallowedMatches, reparse_points: reparsePoints, scanned_files: files.length, status: disallowedMatches.length === 0 && reparsePoints.length === 0 ? "passed" : "failed" };
 }
 
-export async function buildAndValidatePortablePackage({ evidenceDirectory, outputRoot }) {
+export async function buildAndValidatePortablePackage({ evidenceDirectory, outputRoot, releaseRecord }) {
   if (process.platform !== frozenRuntime.os || process.arch !== frozenRuntime.arch || process.version.slice(1) !== frozenRuntime.node) {
     throw new Error("Portable package build requires frozen Node 24.13.0 on win-x64.");
   }
@@ -351,7 +367,8 @@ export async function buildAndValidatePortablePackage({ evidenceDirectory, outpu
   writeJson(join(packageDirectory, "LICENSES", "third-party.json"), { api: apiDependencies, runtime: { node: frozenRuntime.node }, schema_version: "1.0", worker: workerDependencies });
 
   const commit = run("git", ["rev-parse", "HEAD"]);
-  writeJson(join(packageDirectory, "RELEASE.json"), {
+  const finalRelease = releaseRecord !== undefined;
+  writeJson(join(packageDirectory, "RELEASE.json"), releaseRecord ?? {
     app_version: appVersion,
     browsers: [],
     build_commit: commit,
@@ -360,16 +377,20 @@ export async function buildAndValidatePortablePackage({ evidenceDirectory, outpu
     windows_build: null,
   });
   writeFileSync(join(packageDirectory, "START-HERE.txt"), [
-    "Dada P0-A candidate package",
+    finalRelease ? "Dada P0-A first-version portable package" : "Dada P0-A candidate package",
     "",
-    "This candidate is unsigned and is not a final P0-A release.",
+    finalRelease
+      ? "This unsigned first-version package passed the local P0-A release gates recorded in RELEASE.json."
+      : "This candidate is unsigned and is not a final P0-A release.",
     "Verify the adjacent SHA-256 file before first launch.",
     "Windows SmartScreen may warn on first launch because the executable is unsigned.",
     "For an antivirus alert, compare the package hash with the Gitea build record.",
     "Do not disable antivirus protection, add broad exclusions, or skip hash verification.",
     "To update, exit Dada from the tray and replace the complete program directory.",
     "Dada uses 127.0.0.1:43121 and does not support LAN or remote access.",
-    "A final RELEASE.json is created only after WP-7 acceptance.",
+    finalRelease
+      ? "Resend and Amap real-provider validation remain explicitly deferred and are not recorded as passed."
+      : "A final RELEASE.json is created only after WP-7 acceptance.",
     "",
   ].join("\r\n"));
 
@@ -381,7 +402,18 @@ export async function buildAndValidatePortablePackage({ evidenceDirectory, outpu
   const zipSha256 = fileSha256(zipPath);
   const shaPath = `${zipPath}.sha256`;
   writeFileSync(shaPath, `${zipSha256}  ${basename(zipPath)}\n`);
-  const processTree = await verifyExtractedPackage(zipPath, packageName);
+  const supportBrowser = finalRelease ? releaseRecord.browsers[0] : undefined;
+  const processTree = await verifyExtractedPackage(zipPath, packageName, finalRelease ? {
+    brand: supportBrowser.brand,
+    fullVersion: supportBrowser.fullVersion,
+    major: Number.parseInt(supportBrowser.fullVersion.split(".")[0], 10),
+    statusCode: 200,
+  } : {
+    brand: "Google Chrome",
+    fullVersion: "150.0.0.0",
+    major: 150,
+    statusCode: 426,
+  });
   const fileEntries = listFiles(packageDirectory).files.map((path) => ({
     path: relative(packageDirectory, path).replaceAll("\\", "/"),
     sha256: fileSha256(path),
@@ -392,7 +424,7 @@ export async function buildAndValidatePortablePackage({ evidenceDirectory, outpu
     files: fileEntries,
     fixed_port: fixedPort,
     package_name: packageName,
-    release_status: "candidate_unvalidated",
+    release_status: finalRelease ? releaseRecord.releaseStatus : "candidate_unvalidated",
     schema_version: "1.0",
     zip_sha256: zipSha256,
   };

scripts/lib/resend-release-gate.mjs

@@ -0,0 +1,145 @@
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+
+import { validateReleaseCandidateRecord } from "./release-candidate.mjs";
+
+export const RESEND_DAILY_LIMIT = 80;
+export const RESEND_MONTHLY_LIMIT = 2_400;
+export const DELIVERY_CATEGORIES = Object.freeze(["qq", "163", "enterprise"]);
+export const DELIVERY_SAMPLE_SIZE = 20;
+export const DELIVERY_MINIMUM_WITHIN_TWO_MINUTES = 19;
+export const DELIVERY_WINDOW_SECONDS = 120;
+export const EXPECTED_WP7_01_COMMIT = "623cad25b2a2a9a003502c9a92ebd318dad06248";
+
+const emailPattern = /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/i;
+const absolutePathPattern = /(?:[A-Z]:[\\/]|\\\\|\/Users\/|\/home\/)/i;
+const sensitiveKeyPattern = /"(?:api[_ -]?key|secret|password|authorization|bearer|cookie|session[_ -]?token|verification[_ -]?code|private[_ -]?content|prompt|image)"\s*:/i;
+
+function object(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+
+function errorList(...values) {
+  return [...new Set(values.flat().filter((value) => typeof value === "string" && value.length > 0))];
+}
+
+export function validateDomainCheck(value) {
+  const item = object(value);
+  const freeRules = object(item?.free_rules);
+  const spf = object(item?.spf);
+  const dkim = object(item?.dkim);
+  const errors = [];
+  if (item?.schema_version !== "1.0") errors.push("schema_version");
+  if (item?.service !== "resend") errors.push("service");
+  if (item?.source !== "human_controlled_real") errors.push("source");
+  if (item?.status !== "verified") errors.push("status");
+  if (item?.domain_controlled !== true) errors.push("domain_controlled");
+  if (spf?.status !== "pass") errors.push("spf");
+  if (dkim?.status !== "pass") errors.push("dkim");
+  if (freeRules?.status !== "verified") errors.push("free_rules.status");
+  if (freeRules?.daily_limit !== RESEND_DAILY_LIMIT) errors.push("free_rules.daily_limit");
+  if (freeRules?.monthly_limit !== RESEND_MONTHLY_LIMIT) errors.push("free_rules.monthly_limit");
+  if (freeRules?.paid_fallback_enabled !== false) errors.push("free_rules.paid_fallback_enabled");
+  return errorList(errors);
+}
+
+export function validateDeliverySummary(value) {
+  const item = object(value);
+  const errors = [];
+  if (item?.schema_version !== "1.0") errors.push("schema_version");
+  if (item?.service !== "resend") errors.push("service");
+  if (item?.source !== "human_controlled_real") errors.push("source");
+  if (item?.status !== "verified") errors.push("status");
+  if (!Array.isArray(item?.categories) || item.categories.length !== DELIVERY_CATEGORIES.length) {
+    errors.push("categories");
+  } else {
+    const categories = item.categories.map((entry) => entry?.category).sort();
+    if (categories.join("|") !== DELIVERY_CATEGORIES.slice().sort().join("|")) errors.push("categories.names");
+    for (const entry of item.categories) {
+      if (!Number.isInteger(entry?.sent_count) || entry.sent_count !== DELIVERY_SAMPLE_SIZE) errors.push(`${entry?.category ?? "unknown"}.sent_count`);
+      if (!Number.isInteger(entry?.delivered_within_120_seconds)
+        || entry.delivered_within_120_seconds < DELIVERY_MINIMUM_WITHIN_TWO_MINUTES
+        || entry.delivered_within_120_seconds > DELIVERY_SAMPLE_SIZE) {
+        errors.push(`${entry?.category ?? "unknown"}.delivered_within_120_seconds`);
+      }
+      if (!Number.isFinite(entry?.max_latency_seconds) || entry.max_latency_seconds > DELIVERY_WINDOW_SECONDS) errors.push(`${entry?.category ?? "unknown"}.max_latency_seconds`);
+      if (entry?.mock_used !== false) errors.push(`${entry?.category ?? "unknown"}.mock_used`);
+      if (entry?.preseeded_account_used !== false) errors.push(`${entry?.category ?? "unknown"}.preseeded_account_used`);
+    }
+  }
+  return errorList(errors);
+}
+
+export function validateAuthResult(value) {
+  const item = object(value);
+  const ordinary = object(item?.ordinary);
+  const admin = object(item?.admin);
+  const errors = [];
+  if (item?.schema_version !== "1.0") errors.push("schema_version");
+  if (item?.service !== "resend") errors.push("service");
+  if (item?.source !== "human_controlled_real") errors.push("source");
+  if (item?.status !== "verified") errors.push("status");
+  if (item?.mock_used !== false) errors.push("mock_used");
+  if (item?.preseeded_account_used !== false) errors.push("preseeded_account_used");
+  for (const [name, auth] of [["ordinary", ordinary], ["admin", admin]]) {
+    if (auth?.status !== "passed") errors.push(`${name}.status`);
+    if (auth?.chain !== "formal") errors.push(`${name}.chain`);
+    if (auth?.verification_code_source !== "real_delivery") errors.push(`${name}.verification_code_source`);
+  }
+  return errorList(errors);
+}
+
+export function validateRedaction(value, serializedEvidence = "") {
+  const item = object(value);
+  const errors = [];
+  if (item?.schema_version !== "1.0") errors.push("schema_version");
+  if (item?.status !== "passed") errors.push("status");
+  if (item?.forbidden_matches !== 0) errors.push("forbidden_matches");
+  if (item?.credentials_in_evidence !== false) errors.push("credentials_in_evidence");
+  if (item?.mailboxes_in_evidence !== false) errors.push("mailboxes_in_evidence");
+  if (item?.private_content_in_evidence !== false) errors.push("private_content_in_evidence");
+  if (item?.absolute_paths_in_evidence !== false) errors.push("absolute_paths_in_evidence");
+  if (emailPattern.test(serializedEvidence)) errors.push("email_value");
+  if (absolutePathPattern.test(serializedEvidence)) errors.push("absolute_path");
+  if (sensitiveKeyPattern.test(serializedEvidence)) errors.push("sensitive_value");
+  return errorList(errors);
+}
+
+export function validateCandidateReference(record) {
+  try {
+    validateReleaseCandidateRecord(record);
+  } catch (error) {
+    return [error instanceof Error ? "candidate_record_invalid" : "candidate_record_invalid"];
+  }
+  const errors = [];
+  if (record.build_commit !== EXPECTED_WP7_01_COMMIT) errors.push("candidate_build_commit");
+  const versions = new Map((record.browsers ?? []).map((browser) => [browser.brand, browser.full_version]));
+  if (versions.get("Google Chrome") !== "150.0.7871.187") errors.push("chrome_full_version");
+  if (versions.get("Microsoft Edge") !== "151.0.4129.59") errors.push("edge_full_version");
+  return errorList(errors);
+}
+
+export function readJson(path) {
+  if (!path || !existsSync(path)) return undefined;
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return undefined;
+  }
+}
+
+export function fileSha256(path) {
+  return createHash("sha256").update(readFileSync(path)).digest("hex").toUpperCase();
+}
+
+export function validateResendEvidence({ candidate, domainCheck, deliverySummary, authResult, redaction }) {
+  const serializedEvidence = JSON.stringify({ domainCheck, deliverySummary, authResult });
+  const errors = [
+    ...validateCandidateReference(candidate),
+    ...validateDomainCheck(domainCheck),
+    ...validateDeliverySummary(deliverySummary),
+    ...validateAuthResult(authResult),
+    ...validateRedaction(redaction, serializedEvidence),
+  ];
+  return errorList(errors);
+}

scripts/lib/wp7-05-coverage.mjs

@@ -0,0 +1,45 @@
+import path from 'node:path';
+import { REQUIRED_COVERAGE_UNITS } from './wp7-05-ui-gate.mjs';
+
+const ABSOLUTE_PATH = /^(?:[A-Za-z]:[\\/]|[\\/]{2}|\\\\)/;
+
+function assertSafeRelative(value, field) {
+  if (typeof value !== 'string' || !value || ABSOLUTE_PATH.test(value) || path.isAbsolute(value)) {
+    throw new Error(`WP7_05_UNSAFE_${field}`);
+  }
+  const normalized = value.replaceAll('\\', '/');
+  if (normalized.split('/').includes('..')) throw new Error(`WP7_05_UNSAFE_${field}`);
+  return normalized;
+}
+
+export function buildCoverageEvidence({ runId, candidateSha256, coverageUnits, viewports }) {
+  if (!runId || !/^[A-Za-z0-9._-]+$/.test(runId)) throw new Error('WP7_05_INVALID_RUN_ID');
+  if (!/^[A-Fa-f0-9]{64}$/.test(candidateSha256 ?? '')) throw new Error('WP7_05_INVALID_CANDIDATE_HASH');
+  if (!Array.isArray(coverageUnits)) throw new Error('WP7_05_COVERAGE_UNITS_REQUIRED');
+
+  const byPage = new Map();
+  for (const unit of coverageUnits) {
+    if (!REQUIRED_COVERAGE_UNITS.includes(unit.page_id)) throw new Error('WP7_05_UNKNOWN_PAGE');
+    if (byPage.has(unit.page_id)) throw new Error('WP7_05_DUPLICATE_PAGE');
+    if (!Array.isArray(unit.states) || unit.states.length === 0) throw new Error('WP7_05_STATES_REQUIRED');
+    const states = unit.states.map((state) => ({
+      state: assertSafeRelative(state.state, 'STATE'),
+      screenshot_100pct: assertSafeRelative(state.screenshot_100pct, 'SCREENSHOT'),
+      screenshot_200pct: assertSafeRelative(state.screenshot_200pct, 'SCREENSHOT'),
+      trace: assertSafeRelative(state.trace, 'TRACE'),
+    }));
+    byPage.set(unit.page_id, { page_id: unit.page_id, states });
+  }
+  const missing = REQUIRED_COVERAGE_UNITS.filter((page) => !byPage.has(page));
+  if (missing.length) throw new Error(`WP7_05_MISSING_PAGES:${missing.join(',')}`);
+  if (!Array.isArray(viewports) || viewports.length !== 2) throw new Error('WP7_05_VIEWPORTS_REQUIRED');
+
+  return {
+    schema_version: '1.0',
+    task: 'TASK-WP7-05',
+    run_id: runId,
+    candidate_sha256: candidateSha256.toUpperCase(),
+    viewports,
+    coverage_units: REQUIRED_COVERAGE_UNITS.map((page) => byPage.get(page)),
+  };
+}

scripts/lib/wp7-05-ui-gate.mjs

@@ -0,0 +1,71 @@
+import fs from 'node:fs';
+
+export const REQUIRED_COVERAGE_UNITS = Object.freeze([
+  'support-gate', 'user-auth', 'workspace', 'current-task', 'projects',
+  'project-detail', 'editor', 'export', 'credits', 'settings',
+  'preview-user-variant', 'admin-auth', 'admin-overview', 'admin-users',
+  'admin-invites', 'admin-models', 'admin-assets', 'admin-preview',
+  'admin-generations', 'admin-services-storage', 'admin-audit', 'system-ui',
+]);
+
+const REQUIRED_VIEWPORTS = Object.freeze([
+  { width: 1920, height: 1080, deviceScaleFactor: 1, zoom: 100 },
+  { width: 1920, height: 1080, deviceScaleFactor: 1, zoom: 200 },
+]);
+
+function blocked(code, details = {}) {
+  return { status: 'externally_blocked', code, ...details };
+}
+
+export function loadCandidateRecord(path) {
+  if (!path || !fs.existsSync(path)) return blocked('candidate_record_missing');
+  try {
+    const record = JSON.parse(fs.readFileSync(path, 'utf8'));
+    if (!Array.isArray(record.browsers) || record.browsers.length !== 2) {
+      return blocked('candidate_browser_record_incomplete');
+    }
+    const brands = new Set(record.browsers.map((browser) => browser.brand));
+    if (brands.size !== 2 || !brands.has('Google Chrome') || !brands.has('Microsoft Edge')) {
+      return blocked('candidate_browser_pair_invalid');
+    }
+    if (record.windows?.build == null || !record.candidate_package?.sha256 || !record.candidate_package?.fixed_port) {
+      return blocked('candidate_identity_incomplete');
+    }
+    if (record.browsers.some((browser) => !browser.full_version || !browser.major)) {
+      return blocked('candidate_full_version_missing');
+    }
+    return { status: 'ready', record };
+  } catch {
+    return blocked('candidate_record_invalid');
+  }
+}
+
+export function validateCoverageEvidence(evidence) {
+  if (!evidence || !Array.isArray(evidence.coverage_units)) {
+    return blocked('coverage_evidence_missing');
+  }
+  const actual = new Set(evidence.coverage_units.map((unit) => unit.page_id));
+  const missing = REQUIRED_COVERAGE_UNITS.filter((unit) => !actual.has(unit));
+  if (missing.length) return blocked('coverage_units_incomplete', { missing });
+  const missingStates = evidence.coverage_units
+    .filter((unit) => REQUIRED_COVERAGE_UNITS.includes(unit.page_id))
+    .filter((unit) => !Array.isArray(unit.states) || unit.states.length === 0)
+    .map((unit) => unit.page_id);
+  if (missingStates.length) return blocked('coverage_states_incomplete', { missingStates });
+  const viewportKeys = new Set((evidence.viewports ?? []).map((viewport) => JSON.stringify(viewport)));
+  const missingViewports = REQUIRED_VIEWPORTS.filter((viewport) => !viewportKeys.has(JSON.stringify(viewport)));
+  if (missingViewports.length) return blocked('candidate_viewports_incomplete', { missingViewports });
+  return { status: 'ready' };
+}
+
+export function runWp705Gate({ candidatePath, evidence, dependencies = {} }) {
+  const candidate = loadCandidateRecord(candidatePath);
+  if (candidate.status !== 'ready') return candidate;
+  const coverage = validateCoverageEvidence(evidence);
+  if (coverage.status !== 'ready') return coverage;
+  const externalBlockers = Object.entries(dependencies)
+    .filter(([, status]) => status === 'externally_blocked')
+    .map(([task]) => task);
+  if (externalBlockers.length) return blocked('upstream_external_blocked', { externalBlockers });
+  return { status: 'ready_for_execution' };
+}

scripts/lib/wp7-06-prefreeze.mjs

@@ -0,0 +1,62 @@
+const EXPECTED_TRACE_SUMMARY = Object.freeze({
+  acceptanceCriteria: 52,
+  errorCategories: 9,
+  featureModules: 13,
+  parentFamilies: 89,
+  penProductFrames: 18,
+  productContracts: 19,
+  requirements: 109,
+  tasks: 52,
+  testCases: 117,
+  uiPages: 22,
+});
+
+const REQUIRED_UPSTREAM = Object.freeze({
+  "TASK-WP7-01": "passed",
+  "TASK-WP7-02": "passed",
+  "TASK-WP7-03": "deferred_nonblocking_first_version",
+  "TASK-WP7-04": "deferred_nonblocking_first_version",
+  "TASK-WP7-05": "passed",
+});
+
+const shaPattern = /^[0-9a-f]{40}$/i;
+
+export function buildWp706PrefreezeReport({ currentCommit, releaseExists, trace, upstream }) {
+  if (releaseExists) throw new Error("WP7_06_RELEASE_WRITTEN_PREMATURELY");
+  if (!shaPattern.test(currentCommit ?? "")) throw new Error("WP7_06_CURRENT_COMMIT_INVALID");
+  if (trace?.status !== "passed" || !Array.isArray(trace?.errors) || trace.errors.length > 0) {
+    throw new Error("WP7_06_TRACE_VALIDATION_FAILED");
+  }
+  for (const [key, expected] of Object.entries(EXPECTED_TRACE_SUMMARY)) {
+    if (trace.summary?.[key] !== expected) throw new Error(`WP7_06_TRACE_COUNT_MISMATCH:${key}`);
+  }
+
+  for (const [taskId, expectedStatus] of Object.entries(REQUIRED_UPSTREAM)) {
+    const item = upstream?.[taskId];
+    if (!item || !shaPattern.test(item.head ?? "")) throw new Error(`WP7_06_UPSTREAM_HEAD_INVALID:${taskId}`);
+    if (item.merged !== true) throw new Error(`WP7_06_UPSTREAM_NOT_MERGED:${taskId}`);
+    if (item.status !== expectedStatus) throw new Error(`WP7_06_UNSUPPORTED_STATUS:${taskId}`);
+  }
+
+  return {
+    schema_version: "1.0",
+    task_id: "TASK-WP7-06",
+    status: "passed",
+    current_commit: currentCommit.toLowerCase(),
+    release_json_written: false,
+    trace_summary: { ...EXPECTED_TRACE_SUMMARY },
+    upstream: Object.fromEntries(Object.entries(REQUIRED_UPSTREAM).map(([taskId]) => [taskId, {
+      branch: upstream[taskId].branch,
+      head: upstream[taskId].head.toLowerCase(),
+      merged: true,
+      status: upstream[taskId].status,
+    }])),
+    deferred_external_tasks: Object.entries(REQUIRED_UPSTREAM)
+      .filter(([, status]) => status === "deferred_nonblocking_first_version")
+      .map(([taskId]) => taskId),
+    final_release_allowed: false,
+    next_task: "TASK-WP7-07",
+  };
+}
+
+export { EXPECTED_TRACE_SUMMARY, REQUIRED_UPSTREAM };

scripts/lib/wp7-07-final-release.mjs

@@ -0,0 +1,96 @@
+import { createHash } from "node:crypto";
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { extname, join, relative } from "node:path";
+
+const SHA40 = /^[a-f0-9]{40}$/i;
+const SHA64 = /^[a-f0-9]{64}$/i;
+const VERSION = /^[1-9][0-9]*\.[0-9]+\.[0-9]+\.[0-9]+$/;
+const ABSOLUTE_PATH = /(?:[A-Za-z]:[\\/](?:Users|Documents)[\\/][^\\/"'\s]+[\\/]|\/Users\/[^/"'\s]+\/|\/home\/[^/"'\s]+\/)/;
+const CREDENTIAL = /\b(?:sk|key)-[A-Za-z0-9_-]{16,}\b|-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/i;
+const TEXT_EXTENSIONS = new Set([".cjs", ".cs", ".css", ".html", ".js", ".json", ".mjs", ".ts", ".tsx", ".txt", ".xml", ".yaml", ".yml"]);
+
+export const DEFERRED_EXTERNAL_TASKS = Object.freeze(["TASK-WP7-03", "TASK-WP7-04"]);
+
+export function buildFinalReleaseRecord({ appVersion, browsers, buildCommit, frozenFromCommit, recordedAt, windows }) {
+  const record = {
+    appVersion,
+    browsers: browsers.map(({ brand, fullVersion }) => ({ brand, fullVersion })),
+    buildCommit: buildCommit.toLowerCase(),
+    deferredExternalTasks: [...DEFERRED_EXTERNAL_TASKS],
+    finalRelease: true,
+    fixedPort: 43121,
+    frozenFromCommit: frozenFromCommit.toLowerCase(),
+    recordedAt,
+    releaseStatus: "first_version_internal",
+    schemaVersion: "1.0",
+    windows: { arch: windows.arch, build: windows.build, displayVersion: windows.displayVersion },
+  };
+  return validateFinalReleaseRecord(record);
+}
+
+export function validateFinalReleaseRecord(record) {
+  const errors = [];
+  if (record?.schemaVersion !== "1.0") errors.push("schemaVersion");
+  if (record?.releaseStatus !== "first_version_internal") errors.push("releaseStatus");
+  if (record?.finalRelease !== true) errors.push("finalRelease");
+  if (record?.fixedPort !== 43121) errors.push("fixedPort");
+  if (!SHA40.test(record?.buildCommit ?? "")) errors.push("buildCommit");
+  if (!SHA40.test(record?.frozenFromCommit ?? "")) errors.push("frozenFromCommit");
+  if (!Number.isFinite(Date.parse(record?.recordedAt ?? ""))) errors.push("recordedAt");
+  if (!Array.isArray(record?.deferredExternalTasks) || record.deferredExternalTasks.join("|") !== DEFERRED_EXTERNAL_TASKS.join("|")) errors.push("deferredExternalTasks");
+  if (record?.windows?.arch !== "x64" || !/^\d+\.\d+$/.test(record?.windows?.build ?? "")) errors.push("windows");
+  if (!Array.isArray(record?.browsers) || record.browsers.length !== 2) {
+    errors.push("browsers");
+  } else {
+    const brands = record.browsers.map(({ brand }) => brand).sort();
+    if (brands.join("|") !== "Google Chrome|Microsoft Edge") errors.push("browserBrands");
+    for (const browser of record.browsers) {
+      if (!VERSION.test(browser.fullVersion ?? "")) errors.push(`${browser.brand}.fullVersion`);
+      if ("path" in browser || "executablePath" in browser || "executableSha256" in browser) errors.push(`${browser.brand}.privateMetadata`);
+    }
+  }
+  const serialized = JSON.stringify(record);
+  if (ABSOLUTE_PATH.test(serialized) || CREDENTIAL.test(serialized)) errors.push("sensitiveValue");
+  if (errors.length > 0) throw new Error(`WP7_07_RELEASE_INVALID:${[...new Set(errors)].join(",")}`);
+  return record;
+}
+
+export function sha256File(path) {
+  return createHash("sha256").update(readFileSync(path)).digest("hex").toUpperCase();
+}
+
+export function scanReleaseFiles({ roots, allowedFixturePaths = [] }) {
+  const allowed = new Set(allowedFixturePaths.map((value) => value.replaceAll("\\", "/")));
+  const findings = [];
+  let scannedFiles = 0;
+  function visit(root, current = root) {
+    for (const entry of readdirSync(current, { withFileTypes: true })) {
+      if ([".git", ".pnpm-store", "node_modules", "bin", "obj"].includes(entry.name)) continue;
+      const path = join(current, entry.name);
+      if (entry.isDirectory()) {
+        visit(root, path);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+      scannedFiles += 1;
+      if (!TEXT_EXTENSIONS.has(extname(entry.name).toLowerCase())) continue;
+      const logicalPath = relative(root, path).replaceAll("\\", "/");
+      const content = readFileSync(path, "utf8");
+      if (!allowed.has(logicalPath) && ABSOLUTE_PATH.test(content)) findings.push({ path: logicalPath, rule: "absolute_user_path" });
+      if (!allowed.has(logicalPath) && CREDENTIAL.test(content)) findings.push({ path: logicalPath, rule: "credential_shape" });
+    }
+  }
+  for (const root of roots) {
+    if (!statSync(root).isDirectory()) throw new Error(`WP7_07_SCAN_ROOT_INVALID:${root}`);
+    visit(root);
+  }
+  return { findings, scanned_files: scannedFiles, status: findings.length === 0 ? "passed" : "failed" };
+}
+
+export function validateFinalEvidence({ packageManifest, release, releaseSha256, scan }) {
+  validateFinalReleaseRecord(release);
+  if (!SHA64.test(releaseSha256 ?? "")) throw new Error("WP7_07_RELEASE_HASH_INVALID");
+  if (packageManifest?.release_status !== release.releaseStatus || !SHA64.test(packageManifest?.zip_sha256 ?? "")) throw new Error("WP7_07_PACKAGE_MANIFEST_INVALID");
+  if (scan?.status !== "passed" || scan.findings?.length !== 0) throw new Error("WP7_07_LEAK_SCAN_FAILED");
+  return { release_sha256: releaseSha256.toUpperCase(), status: "passed", zip_sha256: packageManifest.zip_sha256.toUpperCase() };
+}

scripts/run-wp7-03-validation.mjs

@@ -0,0 +1,175 @@
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+
+import {
+  fileSha256,
+  readJson,
+  validateCandidateReference,
+  validateResendEvidence,
+} from "./lib/resend-release-gate.mjs";
+
+const phaseIndex = process.argv.indexOf("--phase");
+const phase = phaseIndex >= 0 ? process.argv[phaseIndex + 1] : "green";
+if (!new Set(["red", "green"]).has(phase)) throw new Error(`Unsupported phase: ${phase}`);
+
+const candidateRunId = process.env.DADA_WP7_01_RUN_ID ?? "wp7-01-candidate-20260804052447717";
+const runId = process.env.DADA_TDD_RUN_ID ?? `wp7-03-${phase}-${new Date().toISOString().replace(/[^0-9]/g, "")}`;
+const runDirectory = resolve("artifacts", "tdd", runId);
+const caseId = "TDD-WP7-EXT-002-real-resend";
+const caseDirectory = resolve(runDirectory, "cases", caseId);
+if (existsSync(runDirectory)) throw new Error(`Evidence run already exists: ${runId}`);
+mkdirSync(caseDirectory, { recursive: true });
+
+function writeJson(path, value) {
+  writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function runCommand(name, command) {
+  const startedAt = new Date().toISOString();
+  const result = spawnSync(process.env.ComSpec ?? "cmd.exe", ["/d", "/s", "/c", command], {
+    encoding: "utf8",
+    env: process.env,
+    maxBuffer: 40 * 1024 * 1024,
+    stdio: "inherit",
+  });
+  return {
+    command,
+    exit_code: result.status ?? 1,
+    finished_at: new Date().toISOString(),
+    name,
+    started_at: startedAt,
+  };
+}
+
+const candidateEvidenceRoot = resolve(
+  process.env.DADA_WP7_01_EVIDENCE_DIR ?? join("artifacts", "tdd", candidateRunId),
+);
+const candidate = readJson(join(candidateEvidenceRoot, "release-candidate.json"));
+const candidateErrors = candidate ? validateCandidateReference(candidate) : ["candidate_record_missing"];
+writeJson(resolve(caseDirectory, "candidate-reference.json"), candidate ? {
+  browsers: candidate.browsers.map(({ brand, full_version: fullVersion, major }) => ({ brand, full_version: fullVersion, major })),
+  build_commit: candidate.build_commit,
+  candidate_status: candidate.status,
+  final_release: candidate.final_release,
+  fixed_port: candidate.fixed_port,
+  run_id: candidateRunId,
+  schema_version: "1.0",
+} : {
+  candidate_status: "not_available",
+  reason: "candidate_record_missing",
+  run_id: candidateRunId,
+  schema_version: "1.0",
+});
+
+const commands = phase === "red" ? [] : [
+  ["workspace-build", "pnpm build:workspace-packages"],
+  ["integration", "pnpm test:integration"],
+  ["api", "pnpm check:openapi && pnpm exec vitest run tests/api --maxWorkers=1"],
+  ["security", "pnpm test:security"],
+  ["tdd-trace", "pnpm validate:tdd-trace"],
+].map(([name, command]) => runCommand(name, command));
+const localGatePassed = phase === "red" || commands.length > 0 && commands.every(({ exit_code }) => exit_code === 0);
+
+const redaction = {
+  absolute_paths_in_evidence: false,
+  credentials_in_evidence: false,
+  forbidden_matches: 0,
+  mailboxes_in_evidence: false,
+  private_content_in_evidence: false,
+  schema_version: "1.0",
+  status: "passed",
+};
+const externalRoot = process.env.DADA_RESEND_EVIDENCE_DIR ? resolve(process.env.DADA_RESEND_EVIDENCE_DIR) : undefined;
+const realAuthorized = process.env.DADA_RESEND_REAL_AUTHORIZED === "1";
+const externalFiles = ["domain-check.json", "delivery-summary.json", "auth-result.json", "redaction.json"];
+const externalEvidence = externalRoot
+  ? Object.fromEntries(externalFiles.map((file) => [file, readJson(join(externalRoot, file))]))
+  : {};
+const externalEvidenceMissing = externalRoot ? externalFiles.filter((file) => !externalEvidence[file]) : externalFiles;
+const externalErrors = externalRoot && externalEvidenceMissing.length === 0 && candidate
+  ? validateResendEvidence({
+      authResult: externalEvidence["auth-result.json"],
+      candidate,
+      deliverySummary: externalEvidence["delivery-summary.json"],
+      domainCheck: externalEvidence["domain-check.json"],
+      redaction: externalEvidence["redaction.json"],
+    })
+  : [];
+
+const externalBlockers = [];
+if (candidateErrors.length > 0) externalBlockers.push("candidate_record_unavailable_or_drifted");
+if (!realAuthorized) externalBlockers.push("controlled_domain_or_real_mailbox_authorization_absent");
+if (!externalRoot) externalBlockers.push("real_resend_evidence_not_supplied");
+if (externalRoot && externalEvidenceMissing.length > 0) externalBlockers.push("real_resend_evidence_incomplete");
+if (externalErrors.length > 0) externalBlockers.push("real_resend_evidence_invalid");
+
+if (phase === "red") {
+  writeJson(resolve(caseDirectory, "red-observation.json"), {
+    expected_failure: "Resend SPF/DKIM, free-rule, delivery, and formal authentication evidence is absent before TASK-WP7-03.",
+    observed_commands: ["pnpm test:wp7-03:red"],
+    red_reason: "TDD-WP7-EXT-002 requires controlled real domain/mailbox evidence; mock or pre-seeded accounts are not release evidence.",
+    status: "red_confirmed",
+  });
+} else if (externalRoot && externalEvidenceMissing.length === 0 && candidateErrors.length === 0 && realAuthorized && externalErrors.length === 0) {
+  for (const file of externalFiles) writeJson(resolve(caseDirectory, file), externalEvidence[file]);
+  writeJson(resolve(caseDirectory, "source-hashes.json"), {
+    files: Object.fromEntries(externalFiles.map((file) => [file, fileSha256(join(externalRoot, file))])),
+    schema_version: "1.0",
+  });
+} else {
+  writeJson(resolve(caseDirectory, "blocker.json"), {
+    blockers: externalErrors.length > 0 ? ["real_resend_evidence_invalid"] : externalBlockers,
+    mock_accepted_as_evidence: false,
+    paid_fallback_enabled: false,
+    preseeded_accounts_accepted_as_evidence: false,
+    real_calls_started: false,
+    schema_version: "1.0",
+    status: "externally_blocked",
+  });
+  writeJson(resolve(caseDirectory, "redaction.json"), redaction);
+  writeJson(resolve(caseDirectory, "source-hashes.json"), { files: {}, schema_version: "1.0" });
+}
+
+const expectedEvidence = phase === "red"
+  ? ["candidate-reference.json", "red-observation.json"]
+  : externalRoot && externalEvidenceMissing.length === 0 && candidateErrors.length === 0 && realAuthorized && externalErrors.length === 0
+    ? ["candidate-reference.json", "domain-check.json", "delivery-summary.json", "auth-result.json", "redaction.json", "source-hashes.json"]
+    : ["candidate-reference.json", "blocker.json", "redaction.json", "source-hashes.json"];
+const missingEvidence = expectedEvidence.filter((file) => !existsSync(resolve(caseDirectory, file)));
+const status = phase === "red"
+  ? localGatePassed && missingEvidence.length === 0 ? "red_confirmed" : "failed"
+  : !localGatePassed || missingEvidence.length > 0 ? "failed"
+    : realAuthorized && (!externalRoot || externalEvidenceMissing.length > 0 || externalErrors.length > 0) ? "failed"
+    : externalRoot && externalEvidenceMissing.length === 0 && candidateErrors.length === 0 && realAuthorized && externalErrors.length === 0 ? "passed"
+      : "externally_blocked";
+const manifest = {
+  path: "tasks.manifest.json",
+  sha256: createHash("sha256").update(readFileSync("tasks.manifest.json")).digest("hex").toUpperCase(),
+};
+const result = {
+  acceptance_criteria: ["AC-01", "AC-33", "AC-41", "AC-47", "AC-49"],
+  automation: ["controlled_real", "manual_review"],
+  candidate_run_id: candidateRunId,
+  commit: spawnSync("git", ["rev-parse", "HEAD"], { encoding: "utf8" }).stdout.trim(),
+  evidence_refs: expectedEvidence,
+  external_blockers: phase === "green" && status === "externally_blocked" ? externalBlockers : [],
+  finished_at: new Date().toISOString(),
+  layer: ["EXT-REAL", "MANUAL"],
+  manifest,
+  missing_evidence: missingEvidence,
+  phase,
+  requirements: ["AUTH-01", "AUTH-02", "AUTH-07"],
+  run_id: runId,
+  schema_version: "1.0",
+  status,
+  task_id: "TASK-WP7-03",
+  test_id: caseId,
+  work_package: "WP-7",
+};
+writeJson(resolve(caseDirectory, "commands.json"), { commands, phase, run_id: runId, schema_version: "1.0" });
+writeJson(resolve(caseDirectory, "result.json"), result);
+writeJson(resolve(runDirectory, "evidence.json"), { cases: [{ external_blockers: result.external_blockers, missing_evidence: missingEvidence, status, test_id: caseId }], phase, run_id: runId, status });
+console.log(JSON.stringify({ external_blockers: result.external_blockers, phase, run_id: runId, status }, null, 2));
+if (status === "failed") process.exit(1);

scripts/run-wp7-04-validation.mjs

@@ -0,0 +1,261 @@
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+const runId = process.env.DADA_TDD_RUN_ID ?? `wp7-04-amap-${new Date().toISOString().replace(/[^0-9]/g, "")}`;
+const runDirectory = resolve("artifacts", "tdd", runId);
+const caseDirectory = resolve(runDirectory, "cases", "TDD-WP7-EXT-003-real-amap");
+if (existsSync(runDirectory)) throw new Error(`Evidence run already exists: ${runId}`);
+mkdirSync(caseDirectory, { recursive: true });
+
+function run(command, args, evidenceCommand = [command, ...args].join(" ")) {
+  const startedAt = new Date().toISOString();
+  const executable = process.platform === "win32" ? (process.env.ComSpec ?? "cmd.exe") : command;
+  const actualArgs = process.platform === "win32" ? ["/d", "/s", "/c", [command, ...args].join(" ")] : args;
+  const result = spawnSync(executable, actualArgs, { encoding: "utf8" });
+  return {
+    command: evidenceCommand,
+    exit_code: result.status ?? 1,
+    finished_at: new Date().toISOString(),
+    stderr: result.stderr ?? "",
+    stdout: result.stdout ?? "",
+    started_at: startedAt,
+  };
+}
+
+function skipped(command) {
+  const timestamp = new Date().toISOString();
+  return { command, exit_code: 1, finished_at: timestamp, started_at: timestamp, stderr: "prerequisite_failed", stdout: "" };
+}
+
+function readConsoleReview() {
+  const raw = process.env.DADA_AMAP_CONSOLE_REVIEW_JSON;
+  const fallback = {
+    allowlist: "not_verified",
+    auto_scaling: "not_verified",
+    paid_fallback: "not_verified",
+    qps: "not_verified",
+    qps_limit_per_second: null,
+    reviewed_at: null,
+    security_restriction: "not_verified",
+    service_binding: "not_verified",
+    source: "not_supplied",
+    valid: true,
+  };
+  if (!raw) return fallback;
+  try {
+    const parsed = JSON.parse(raw);
+    const requiredKeys = ["allowlist", "auto_scaling", "paid_fallback", "qps", "qps_limit_per_second", "reviewed_at", "security_restriction", "service_binding", "source"];
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed) || Object.keys(parsed).sort().join("|") !== requiredKeys.sort().join("|")) {
+      return { ...fallback, source: "invalid_input", valid: false };
+    }
+    const statusFields = ["allowlist", "qps", "security_restriction", "service_binding"];
+    const statusValid = statusFields.every((field) => ["failed", "not_verified", "passed"].includes(parsed[field]));
+    const disabledFieldsValid = ["auto_scaling", "paid_fallback"].every((field) => ["disabled", "not_verified"].includes(parsed[field]));
+    const qpsLimitValid = parsed.qps === "passed"
+      ? Number.isSafeInteger(parsed.qps_limit_per_second) && parsed.qps_limit_per_second >= 1 && parsed.qps_limit_per_second <= 1_000
+      : parsed.qps_limit_per_second === null;
+    const reviewedAtValid = typeof parsed.reviewed_at === "string" && Number.isFinite(Date.parse(parsed.reviewed_at));
+    if (!statusValid || !disabledFieldsValid || !qpsLimitValid || !reviewedAtValid || parsed.source !== "amap_console_manual_review") {
+      return { ...fallback, source: "invalid_input", valid: false };
+    }
+    return { ...parsed, valid: true };
+  } catch {
+    return { ...fallback, source: "invalid_input", valid: false };
+  }
+}
+
+function writeJson(path, value) {
+  writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function probeCode(value) {
+  return typeof value === "string" && /^[a-z0-9_]{1,64}$/.test(value) ? value : "invalid_output";
+}
+
+function containsForbiddenEvidence(value) {
+  const serialized = JSON.stringify(value);
+  return [
+    /[A-Za-z]:[\\/](?:Users|Documents)[\\/]/i,
+    /"(?:api[_-]?key|credential|secret_value|latitude|longitude|coordinates|email_address|ip_address)"\s*:/i,
+    /-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/,
+  ].some((pattern) => pattern.test(serialized));
+}
+
+const consoleReview = readConsoleReview();
+const build = run("pnpm", ["build:workspace-packages"]);
+const locationRegression = build.exit_code === 0
+  ? run("pnpm", ["exec", "vitest", "run", "tests/api/wp4-04-location.test.ts"])
+  : skipped("pnpm exec vitest run tests/api/wp4-04-location.test.ts");
+const serviceRegression = build.exit_code === 0
+  ? run("pnpm", ["exec", "vitest", "run", "tests/api/wp6-03-services.test.ts"])
+  : skipped("pnpm exec vitest run tests/api/wp6-03-services.test.ts");
+const localHardStop = build.exit_code === 0
+  ? run("pnpm", ["exec", "vitest", "run", "tests/api/wp7-04-amap-release-gate.test.ts"])
+  : skipped("pnpm exec vitest run tests/api/wp7-04-amap-release-gate.test.ts");
+const productionAdapter = build.exit_code === 0
+  ? run("pnpm", ["exec", "vitest", "run", "tests/api/wp7-04-amap-production-adapter.test.ts"])
+  : skipped("pnpm exec vitest run tests/api/wp7-04-amap-production-adapter.test.ts");
+const consentFlow = build.exit_code === 0
+  ? run("pnpm", ["exec", "vitest", "run", "tests/unit/wp4-04-palette-dynamic.test.ts"])
+  : skipped("pnpm exec vitest run tests/unit/wp4-04-palette-dynamic.test.ts");
+const supervisorBuild = run("dotnet", ["build", "supervisor/Dada.Supervisor/Dada.Supervisor.csproj", "--configuration", "Release"]);
+const supervisorSecurity = supervisorBuild.exit_code === 0
+  ? run("dotnet", ["run", "--project", "supervisor/Dada.Supervisor.Tests/Dada.Supervisor.Tests.csproj", "--configuration", "Release"])
+  : skipped("dotnet run --project supervisor/Dada.Supervisor.Tests/Dada.Supervisor.Tests.csproj --configuration Release");
+const supervisorExe = resolve("supervisor", "Dada.Supervisor", "bin", "Release", "net8.0-windows", "Dada.Supervisor.exe");
+const external = supervisorBuild.exit_code === 0 && existsSync(supervisorExe)
+  ? run(supervisorExe, ["secrets", "probe", "api-amap"], "Dada.Supervisor.exe secrets probe api-amap")
+  : skipped("Dada.Supervisor.exe secrets probe api-amap");
+const trace = run("pnpm", ["validate:tdd-trace"]);
+const security = run("pnpm", ["test:security"]);
+const commands = [build, locationRegression, serviceRegression, localHardStop, productionAdapter, consentFlow, supervisorBuild, supervisorSecurity, external, trace, security]
+  .map(({ command, exit_code, finished_at, started_at }) => ({ command, exit_code, finished_at, started_at }));
+const parsedExternal = (() => {
+  try { return JSON.parse(external.stdout.trim().split(/\r?\n/).at(-1) ?? ""); } catch { return {}; }
+})();
+const safeProbeCode = probeCode(parsedExternal.code);
+const realCalls = Number.isSafeInteger(parsedExternal.real_calls) && parsedExternal.real_calls >= 0 && parsedExternal.real_calls <= 2
+  ? parsedExternal.real_calls
+  : 0;
+const probePassed = external.exit_code === 0 && safeProbeCode === "amap_probe_passed" && realCalls === 2;
+const hardStopPassed = localHardStop.exit_code === 0;
+const productionAdapterPassed = productionAdapter.exit_code === 0;
+const consentPassed = consentFlow.exit_code === 0;
+const supervisorSecurityPassed = supervisorSecurity.exit_code === 0;
+const regressionPassed = locationRegression.exit_code === 0 && serviceRegression.exit_code === 0;
+const automatedPassed = build.exit_code === 0 && hardStopPassed && productionAdapterPassed && consentPassed && supervisorSecurityPassed && regressionPassed && trace.exit_code === 0 && security.exit_code === 0;
+const manualReviewPassed = consoleReview.valid
+  && consoleReview.service_binding === "passed"
+  && consoleReview.qps === "passed"
+  && consoleReview.allowlist === "passed"
+  && consoleReview.security_restriction === "passed"
+  && consoleReview.paid_fallback === "disabled"
+  && consoleReview.auto_scaling === "disabled";
+
+const requiredBeforeRelease = [];
+if (!probePassed) requiredBeforeRelease.push("real_location_and_reverse_geocode");
+if (consoleReview.service_binding !== "passed") requiredBeforeRelease.push("service_binding");
+if (consoleReview.qps !== "passed") requiredBeforeRelease.push("qps_confirmation");
+if (consoleReview.allowlist !== "passed") requiredBeforeRelease.push("allowlist_confirmation");
+if (consoleReview.security_restriction !== "passed") requiredBeforeRelease.push("security_restriction");
+if (consoleReview.paid_fallback !== "disabled") requiredBeforeRelease.push("paid_fallback_disabled");
+if (consoleReview.auto_scaling !== "disabled") requiredBeforeRelease.push("auto_scaling_disabled");
+if (!hardStopPassed) requiredBeforeRelease.push("monthly_1000_hard_stop");
+if (!productionAdapterPassed) requiredBeforeRelease.push("production_amap_adapter");
+if (!consentPassed) requiredBeforeRelease.push("dyn004_confirmation");
+if (!supervisorSecurityPassed) requiredBeforeRelease.push("controlled_probe_security");
+
+const blocker = !automatedPassed
+  ? "automated_regression_failed"
+  : !probePassed
+    ? safeProbeCode
+    : !consoleReview.valid
+      ? "manual_review_invalid"
+      : consoleReview.allowlist === "failed"
+        ? "amap_allowlist_unconfigured"
+        : consoleReview.security_restriction === "failed"
+          ? "amap_security_restriction_unconfigured"
+          : !manualReviewPassed
+            ? "manual_acceptance_required"
+            : null;
+const status = !automatedPassed ? "failed" : probePassed && manualReviewPassed ? "passed" : "externally_blocked";
+
+const contractEvidence = {
+  blocker,
+  checks: {
+    allowlist: consoleReview.allowlist === "passed" ? "manual_console_passed" : consoleReview.allowlist,
+    auto_scaling: consoleReview.auto_scaling,
+    client_security_controls: productionAdapterPassed && supervisorSecurityPassed ? "automated_passed" : "failed",
+    controlled_probe_security: supervisorSecurityPassed ? "automated_passed" : "failed",
+    dyn004_hard_stop: consentPassed ? "confirmation_contract_passed" : "failed",
+    location_and_reverse_geocode: probePassed ? "real_probe_passed" : "not_verified",
+    monthly_hard_limit_1000: hardStopPassed ? "local_pre_egress_passed" : "failed",
+    paid_fallback: consoleReview.paid_fallback,
+    production_adapter: productionAdapterPassed ? "credential_channel_real_adapter_passed" : "failed",
+    provider_qps: consoleReview.qps === "passed" ? "manual_console_passed" : consoleReview.qps,
+    provider_qps_limit_per_second: consoleReview.qps_limit_per_second,
+    security_binding: consoleReview.security_restriction === "passed" ? "manual_console_passed" : consoleReview.security_restriction,
+    service_binding: consoleReview.service_binding === "passed" ? "manual_console_passed" : consoleReview.service_binding,
+  },
+  mode: probePassed ? "controlled_real" : "blocked",
+  real_calls: realCalls,
+  status,
+  schema_version: "1.1",
+};
+const externalCallsEvidence = {
+  blocker,
+  mode: probePassed ? "controlled_real" : "blocked",
+  real_calls: realCalls,
+  request_scope: ["geocoding", "reverse_geocoding"],
+  service: "amap",
+  source_command_status: safeProbeCode,
+  status,
+  schema_version: "1.1",
+};
+const manualReviewEvidence = {
+  blocker,
+  checks: {
+    allowlist: consoleReview.allowlist,
+    auto_scaling: consoleReview.auto_scaling,
+    paid_fallback: consoleReview.paid_fallback,
+    qps: consoleReview.qps,
+    qps_limit_per_second: consoleReview.qps_limit_per_second,
+    security_restriction: consoleReview.security_restriction,
+    service_binding: consoleReview.service_binding,
+  },
+  required_before_release: requiredBeforeRelease,
+  reviewed_at: consoleReview.reviewed_at,
+  source: consoleReview.source,
+  status,
+  schema_version: "1.1",
+};
+const result = {
+  acceptance_criteria: ["AC-17", "AC-41", "AC-47"],
+  automation: ["controlled_real", "manual_review"],
+  blocker,
+  contract_regression: automatedPassed ? "passed" : "failed",
+  external_calls: realCalls,
+  finished_at: new Date().toISOString(),
+  manifest: { path: "tasks.manifest.json", sha256: createHash("sha256").update(readFileSync("tasks.manifest.json")).digest("hex").toUpperCase() },
+  missing_evidence: requiredBeforeRelease,
+  parent_family: "TDD-WP7-EXT-003",
+  phase: "green",
+  release_gate: ["release:P0-A"],
+  requirements: ["DYN-04", "PRIV-03"],
+  run_id: runId,
+  schema_version: "1.1",
+  status,
+  task_id: "TASK-WP7-04",
+  test_id: "TDD-WP7-EXT-003-real-amap",
+  work_package: "WP-7",
+};
+const commandsEvidence = { commands, run_id: runId, schema_version: "1.1" };
+const evidenceIndex = { cases: [{ status: result.status, test_id: result.test_id }], run_id: runId, status: result.status, schema_version: "1.1" };
+const redactionInputs = [contractEvidence, externalCallsEvidence, manualReviewEvidence, result, commandsEvidence, evidenceIndex];
+const evidenceRedactionPassed = !redactionInputs.some(containsForbiddenEvidence);
+const redactionEvidence = {
+  findings: evidenceRedactionPassed ? [] : ["forbidden_evidence_field"],
+  forbidden_fields_present: !evidenceRedactionPassed,
+  source_security_scan: security.exit_code === 0 ? "passed" : "failed",
+  status: evidenceRedactionPassed && security.exit_code === 0 ? "passed" : "failed",
+  stored_fields: ["service", "status", "logical_limit", "manual_review_status", "qps_limit_per_second"],
+  schema_version: "1.1",
+};
+if (redactionEvidence.status !== "passed") {
+  result.status = "failed";
+  result.blocker = "redaction_failed";
+  evidenceIndex.status = "failed";
+  evidenceIndex.cases[0].status = "failed";
+}
+
+writeJson(resolve(caseDirectory, "amap-contract.json"), contractEvidence);
+writeJson(resolve(caseDirectory, "external-calls.json"), externalCallsEvidence);
+writeJson(resolve(caseDirectory, "redaction.json"), redactionEvidence);
+writeJson(resolve(caseDirectory, "manual-review.json"), manualReviewEvidence);
+writeJson(resolve(caseDirectory, "commands.json"), commandsEvidence);
+writeJson(resolve(caseDirectory, "result.json"), result);
+writeJson(resolve(runDirectory, "evidence.json"), evidenceIndex);
+console.log(JSON.stringify(result, null, 2));
+if (result.status === "failed") process.exit(1);

scripts/run-wp7-05-validation.mjs

@@ -0,0 +1,13 @@
+import { runWp705Gate } from './lib/wp7-05-ui-gate.mjs';
+
+const result = runWp705Gate({
+  candidatePath: process.env.WP7_01_CANDIDATE_RECORD,
+  evidence: null,
+  dependencies: {
+    'TASK-WP7-03': 'externally_blocked',
+    'TASK-WP7-04': 'externally_blocked',
+  },
+});
+
+console.log(JSON.stringify({ task: 'TASK-WP7-05', ...result }));
+process.exitCode = result.status === 'ready_for_execution' ? 0 : 3;

scripts/run-wp7-06-validation.mjs

@@ -0,0 +1,108 @@
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+import { validateTddTrace } from "./lib/tdd-trace.mjs";
+import { buildWp706PrefreezeReport, REQUIRED_UPSTREAM } from "./lib/wp7-06-prefreeze.mjs";
+
+const runId = process.env.DADA_TDD_RUN_ID ?? `wp7-06-prefreeze-${new Date().toISOString().replace(/[^0-9]/g, "")}`;
+const runDirectory = resolve("artifacts", "tdd", runId);
+const caseDirectory = resolve(runDirectory, "cases", "TDD-WP7-AC-001-trace-structure");
+if (existsSync(runDirectory)) throw new Error(`Evidence run already exists: ${runId}`);
+mkdirSync(caseDirectory, { recursive: true });
+
+function writeJson(path, value) {
+  writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function git(args) {
+  const result = spawnSync("git", args, { encoding: "utf8", timeout: 60_000 });
+  if ((result.status ?? 1) !== 0) throw new Error(`WP7_06_GIT_COMMAND_FAILED:${args[0]}`);
+  return result.stdout.trim();
+}
+
+function runCommand(name, command) {
+  const startedAt = new Date().toISOString();
+  const result = spawnSync(process.env.ComSpec ?? "cmd.exe", ["/d", "/s", "/c", command], {
+    encoding: "utf8",
+    env: process.env,
+    maxBuffer: 64 * 1024 * 1024,
+  });
+  if (result.stdout) process.stdout.write(result.stdout);
+  if (result.stderr) process.stderr.write(result.stderr);
+  return {
+    command,
+    exit_code: result.status ?? 1,
+    finished_at: new Date().toISOString(),
+    name,
+    started_at: startedAt,
+  };
+}
+
+const commands = [
+  runCommand("prefreeze-unit", "node --test tests/package/wp7-06-prefreeze.test.mjs"),
+  runCommand("tdd-trace", "pnpm validate:tdd-trace"),
+];
+if (commands.some((command) => command.exit_code !== 0)) {
+  writeJson(resolve(caseDirectory, "commands.json"), { commands, run_id: runId, schema_version: "1.0" });
+  process.exit(1);
+}
+
+const trace = validateTddTrace();
+const currentCommit = git(["rev-parse", "HEAD"]);
+const remoteLines = git(["ls-remote", "--heads", "origin", "codex/wp7-01", "codex/wp7-02", "codex/wp7-03", "codex/wp7-04", "codex/wp7-05"])
+  .split(/\r?\n/)
+  .filter(Boolean);
+const remoteHeads = Object.fromEntries(remoteLines.map((line) => {
+  const [head, reference] = line.split(/\s+/);
+  return [reference.replace("refs/heads/", ""), head];
+}));
+const upstream = Object.fromEntries(Object.entries(REQUIRED_UPSTREAM).map(([taskId, status]) => {
+  const branch = taskId.replace("TASK-", "codex/").toLowerCase();
+  const head = remoteHeads[branch];
+  const ancestry = spawnSync("git", ["merge-base", "--is-ancestor", head ?? "missing", "HEAD"], { encoding: "utf8", timeout: 30_000 });
+  return [taskId, { branch, head, merged: ancestry.status === 0, status }];
+}));
+const report = buildWp706PrefreezeReport({
+  currentCommit,
+  releaseExists: existsSync(resolve("RELEASE.json")),
+  trace,
+  upstream,
+});
+
+const result = {
+  acceptance_criteria: Array.from({ length: 56 }, (_, index) => index + 1)
+    .filter((number) => ![8, 26, 37, 54].includes(number))
+    .map((number) => `AC-${String(number).padStart(2, "0")}`),
+  automation: ["automated", "manual_review"],
+  commit: currentCommit,
+  evidence_refs: ["commands.json", "trace-summary.json", "upstream-lineage.json", "deferred-external.json"],
+  finished_at: new Date().toISOString(),
+  manifest: {
+    path: "tasks.manifest.json",
+    sha256: createHash("sha256").update(readFileSync("tasks.manifest.json")).digest("hex").toUpperCase(),
+  },
+  missing_evidence: [],
+  release_gate: ["release:P0-A"],
+  requirements: ["NFR-05"],
+  run_id: runId,
+  schema_version: "1.0",
+  status: report.status,
+  task_id: "TASK-WP7-06",
+  test_id: "TDD-WP7-AC-001-trace-structure",
+  work_package: "WP-7",
+};
+
+writeJson(resolve(caseDirectory, "commands.json"), { commands, run_id: runId, schema_version: "1.0" });
+writeJson(resolve(caseDirectory, "trace-summary.json"), { status: trace.status, summary: trace.summary, schema_version: "1.0" });
+writeJson(resolve(caseDirectory, "upstream-lineage.json"), { current_commit: currentCommit, tasks: report.upstream, schema_version: "1.0" });
+writeJson(resolve(caseDirectory, "deferred-external.json"), {
+  policy: "product_owner_first_version_nonblocking",
+  tasks: report.deferred_external_tasks,
+  treated_as_real_provider_pass: false,
+  schema_version: "1.0",
+});
+writeJson(resolve(caseDirectory, "result.json"), result);
+writeJson(resolve(runDirectory, "evidence.json"), { cases: [{ missing_evidence: [], status: result.status, test_id: result.test_id }], run_id: runId, status: result.status, schema_version: "1.0" });
+console.log(JSON.stringify({ deferred_external_tasks: report.deferred_external_tasks, next_task: report.next_task, run_id: runId, status: report.status }, null, 2));

scripts/run-wp7-07-validation.mjs

@@ -0,0 +1,157 @@
+import { spawnSync } from "node:child_process";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, join, resolve } from "node:path";
+
+import { buildAndValidatePortablePackage } from "./lib/portable-package.mjs";
+import { readCandidateEnvironment } from "./lib/release-candidate.mjs";
+import {
+  buildFinalReleaseRecord,
+  scanReleaseFiles,
+  sha256File,
+  validateFinalEvidence,
+} from "./lib/wp7-07-final-release.mjs";
+
+const runId = process.env.DADA_TDD_RUN_ID ?? `wp7-07-final-${new Date().toISOString().replace(/[^0-9]/g, "")}`;
+const runDirectory = resolve("artifacts", "tdd", runId);
+const releaseCase = resolve(runDirectory, "cases", "TDD-WP7-REL-001-final-release-record");
+const securityCase = resolve(runDirectory, "cases", "TDD-WP7-SEC-001-artifact-leak-scan");
+const outputRoot = resolve(".build", "wp7-07-final-release");
+if (existsSync(runDirectory)) throw new Error(`Evidence run already exists: ${runId}`);
+mkdirSync(releaseCase, { recursive: true });
+mkdirSync(securityCase, { recursive: true });
+
+function writeJson(path, value) {
+  writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function git(args) {
+  const result = spawnSync("git", args, { encoding: "utf8", maxBuffer: 64 * 1024 * 1024, timeout: 120_000 });
+  if ((result.status ?? 1) !== 0) throw new Error(`WP7_07_GIT_FAILED:${args.join(" ")}`);
+  return result.stdout.trim();
+}
+
+function gitGrep(args) {
+  const result = spawnSync("git", ["grep", ...args], { encoding: "utf8", maxBuffer: 64 * 1024 * 1024, timeout: 120_000 });
+  if (![0, 1].includes(result.status ?? 2)) throw new Error("WP7_07_GIT_GREP_FAILED");
+  return result.status === 0 ? result.stdout.trim() : "";
+}
+
+function run(name, command) {
+  const startedAt = new Date().toISOString();
+  const result = spawnSync(process.env.ComSpec ?? "cmd.exe", ["/d", "/s", "/c", command], {
+    encoding: "utf8",
+    env: process.env,
+    maxBuffer: 64 * 1024 * 1024,
+  });
+  if (result.stdout) process.stdout.write(result.stdout);
+  if (result.stderr) process.stderr.write(result.stderr);
+  return { command, exit_code: result.status ?? 1, finished_at: new Date().toISOString(), name, started_at: startedAt };
+}
+
+const currentCommit = git(["rev-parse", "HEAD"]);
+const prefreezeCommit = git(["ls-remote", "origin", "refs/heads/codex/wp7-06"]).split(/\s+/)[0];
+if (!prefreezeCommit || spawnSync("git", ["merge-base", "--is-ancestor", prefreezeCommit, "HEAD"]).status !== 0) {
+  throw new Error("WP7_07_PREFREEZE_LINEAGE_INVALID");
+}
+
+const commands = [
+  run("unit", "node --test tests/package/wp7-07-final-release.test.mjs"),
+  run("security", "pnpm test:security"),
+  run("trace", "pnpm validate:tdd-trace"),
+];
+if (commands.some(({ exit_code }) => exit_code !== 0)) {
+  writeJson(join(releaseCase, "commands.json"), { commands, run_id: runId, schema_version: "1.0" });
+  process.exit(1);
+}
+
+const environment = readCandidateEnvironment();
+const packageJson = JSON.parse(readFileSync("package.json", "utf8"));
+const release = buildFinalReleaseRecord({
+  appVersion: packageJson.version,
+  browsers: environment.browsers.map(({ brand, full_version }) => ({ brand, fullVersion: full_version })),
+  buildCommit: currentCommit,
+  frozenFromCommit: prefreezeCommit,
+  recordedAt: new Date().toISOString(),
+  windows: {
+    arch: environment.windows.arch,
+    build: environment.windows.build,
+    displayVersion: environment.windows.display_version,
+  },
+});
+writeJson(resolve("RELEASE.json"), release);
+
+const packageResult = await buildAndValidatePortablePackage({ evidenceDirectory: releaseCase, outputRoot, releaseRecord: release });
+const packageDirectory = join(outputRoot, packageResult.packageManifest.package_name);
+const zipPath = join(outputRoot, `${packageResult.packageManifest.package_name}.zip`);
+const releaseSha256 = sha256File(resolve("RELEASE.json"));
+const packageReleaseSha256 = sha256File(join(packageDirectory, "RELEASE.json"));
+if (releaseSha256 !== packageReleaseSha256) throw new Error("WP7_07_PACKAGE_RELEASE_DRIFT");
+
+const finalScan = scanReleaseFiles({ roots: [packageDirectory, releaseCase] });
+const trackedSensitive = gitGrep(["-I", "-n", "-E", "C:\\\\Users\\\\[^\\\\]+|sk-[A-Za-z0-9_-]{24,}", "HEAD", "--", ":!tests", ":!scripts/lib/wp7-07-final-release.mjs"]);
+const scan = {
+  ...finalScan,
+  git_current_findings: trackedSensitive ? trackedSensitive.split(/\r?\n/).filter(Boolean) : [],
+  status: finalScan.status === "passed" && !trackedSensitive ? "passed" : "failed",
+};
+writeJson(join(securityCase, "scan-report.json"), scan);
+writeJson(join(securityCase, "allowlist.json"), {
+  entries: ["tests/**:synthetic security traps", "scripts/lib/wp7-07-final-release.mjs:scanner patterns"],
+  real_values_allowed: false,
+  schema_version: "1.0",
+});
+if (scan.status !== "passed") throw new Error("WP7_07_LEAK_SCAN_FAILED");
+
+const finalEvidence = validateFinalEvidence({ packageManifest: packageResult.packageManifest, release, releaseSha256, scan });
+copyFileSync(resolve("RELEASE.json"), join(releaseCase, "RELEASE.json"));
+copyFileSync(join(packageDirectory, "START-HERE.txt"), join(releaseCase, "START-HERE.txt"));
+writeJson(join(releaseCase, "environment.json"), {
+  browsers: release.browsers,
+  fixed_port: release.fixedPort,
+  windows: release.windows,
+  schema_version: "1.0",
+});
+writeJson(join(releaseCase, "final-package.json"), {
+  file_name: basename(zipPath),
+  release_sha256: finalEvidence.release_sha256,
+  release_status: release.releaseStatus,
+  zip_sha256: finalEvidence.zip_sha256,
+  schema_version: "1.0",
+});
+writeJson(join(releaseCase, "commands.json"), { commands, run_id: runId, schema_version: "1.0" });
+writeJson(join(releaseCase, "result.json"), {
+  acceptance_criteria: ["AC-24", "AC-41", "AC-48", "AC-56"],
+  deferred_external_tasks: release.deferredExternalTasks,
+  evidence_refs: ["RELEASE.json", "START-HERE.txt", "environment.json", "package-manifest.json", "final-package.json"],
+  release_gate: ["release:P0-A"],
+  requirements: ["NFR-01", "NFR-09", "PRIV-01", "PRIV-02"],
+  status: "passed",
+  task_id: "TASK-WP7-07",
+  test_id: "TDD-WP7-REL-001-final-release-record",
+});
+writeJson(join(securityCase, "result.json"), {
+  evidence_refs: ["scan-report.json", "allowlist.json"],
+  status: "passed",
+  task_id: "TASK-WP7-07",
+  test_id: "TDD-WP7-SEC-001-artifact-leak-scan",
+});
+writeJson(join(runDirectory, "evidence.json"), {
+  cases: [
+    { missing_evidence: [], status: "passed", test_id: "TDD-WP7-REL-001-final-release-record" },
+    { missing_evidence: [], status: "passed", test_id: "TDD-WP7-SEC-001-artifact-leak-scan" },
+  ],
+  deferred_external_tasks: release.deferredExternalTasks,
+  release_sha256: finalEvidence.release_sha256,
+  run_id: runId,
+  status: "passed",
+  zip_sha256: finalEvidence.zip_sha256,
+  schema_version: "1.0",
+});
+
+console.log(JSON.stringify({
+  deferred_external_tasks: release.deferredExternalTasks,
+  release_sha256: finalEvidence.release_sha256,
+  run_id: runId,
+  status: "passed",
+  zip_sha256: finalEvidence.zip_sha256,
+}, null, 2));

supervisor/Dada.Supervisor.Tests/Program.cs

@@ -38,6 +38,7 @@ internal static class Program
         {
             var security = await TestCredentialBoundaryAsync();
             var supervisor = await TestSupervisorLifecycleAsync();
+            await TestAmapProbeSecurityAsync();
             TestSecureConfigurationPersistence();
             TestStructuredLogging();
             WriteEvidence(Environment.GetEnvironmentVariable("DADA_EVIDENCE_DIR_SEC"), security);
@@ -52,6 +53,20 @@ internal static class Program
         }
     }
 
+    private static async Task TestAmapProbeSecurityAsync()
+    {
+        using var handler = AmapProbe.CreateHandler();
+        False(handler.AllowAutoRedirect, "Amap probe redirects disabled");
+        Equal(1, handler.MaxConnectionsPerServer, "Amap probe per-server connection cap");
+        True(AmapProbe.IsAllowedEndpoint(new Uri("https://restapi.amap.com/v3/geocode/regeo")), "Amap fixed HTTPS endpoint accepted");
+        False(AmapProbe.IsAllowedEndpoint(new Uri("http://restapi.amap.com/v3/geocode/regeo")), "Amap HTTP endpoint rejected");
+        False(AmapProbe.IsAllowedEndpoint(new Uri("https://example.invalid/v3/geocode/regeo")), "Amap alternate host rejected");
+        using var oversized = new ByteArrayContent(new byte[AmapProbe.MaximumResponseBytes + 1]);
+        await ThrowsAsync<InvalidDataException>(
+            () => AmapProbe.ReadBoundedJsonAsync(oversized),
+            "Amap oversized response must be rejected before parsing");
+    }
+
     private static void TestStructuredLogging()
     {
         Equal(10 * 1024 * 1024L, StructuredJsonlLogger.SizeLimitBytes, "Supervisor log byte limit");

supervisor/Dada.Supervisor/AmapProbe.cs

@@ -0,0 +1,107 @@
+using System.Buffers;
+using System.Net;
+using System.Text.Json;
+
+namespace Dada.Supervisor;
+
+internal static class AmapProbe
+{
+    internal const int MaximumResponseBytes = 65_536;
+    private const string ProviderHostname = "restapi.amap.com";
+    private static readonly HttpClient Client = new(CreateHandler()) { Timeout = TimeSpan.FromSeconds(15) };
+
+    internal static SocketsHttpHandler CreateHandler() => new()
+    {
+        AllowAutoRedirect = false,
+        AutomaticDecompression = DecompressionMethods.None,
+        ConnectTimeout = TimeSpan.FromSeconds(10),
+        MaxConnectionsPerServer = 1,
+    };
+
+    internal static bool IsAllowedEndpoint(Uri endpoint) =>
+        endpoint.Scheme == Uri.UriSchemeHttps
+        && endpoint.Host.Equals(ProviderHostname, StringComparison.OrdinalIgnoreCase)
+        && (endpoint.IsDefaultPort || endpoint.Port == 443)
+        && string.IsNullOrEmpty(endpoint.UserInfo)
+        && endpoint.AbsolutePath is "/v3/geocode/regeo" or "/v3/geocode/geo";
+
+    internal static int Run(string? key)
+    {
+        if (string.IsNullOrWhiteSpace(key))
+        {
+            Write("amap_credentials_missing", false, 0, null, null);
+            return 3;
+        }
+
+        var realCalls = 0;
+        try
+        {
+            realCalls += 1;
+            var reverse = Call("https://restapi.amap.com/v3/geocode/regeo?location=120.6994,27.9943&extensions=base", key).GetAwaiter().GetResult();
+            realCalls += 1;
+            var geocode = Call($"https://restapi.amap.com/v3/geocode/geo?address={Uri.EscapeDataString("北京市天安门")}", key).GetAwaiter().GetResult();
+            var success = reverse.Status == "1" && geocode.Status == "1";
+            Write(success ? "amap_probe_passed" : "amap_provider_rejected", success, realCalls, reverse.Status, geocode.Status);
+            return success ? 0 : 3;
+        }
+        catch (TaskCanceledException)
+        {
+            Write("amap_probe_timeout", false, realCalls, null, null);
+            return 3;
+        }
+        catch (HttpRequestException exception)
+        {
+            Write($"amap_probe_network_{exception.StatusCode?.ToString() ?? "error"}", false, realCalls, null, null);
+            return 3;
+        }
+        catch (Exception exception) when (exception is JsonException or InvalidDataException)
+        {
+            Write("amap_probe_invalid_response", false, realCalls, null, null);
+            return 3;
+        }
+    }
+
+    private static async Task<ProbeResponse> Call(string endpoint, string key)
+    {
+        var requestUri = new Uri($"{endpoint}&key={Uri.EscapeDataString(key)}", UriKind.Absolute);
+        if (!IsAllowedEndpoint(requestUri)) throw new InvalidDataException("amap_endpoint_rejected");
+        using var request = new HttpRequestMessage(HttpMethod.Get, requestUri);
+        using var response = await Client.SendAsync(request, HttpCompletionOption.ResponseHeadersRead);
+        response.EnsureSuccessStatusCode();
+        using var document = await ReadBoundedJsonAsync(response.Content);
+        var root = document.RootElement;
+        return new ProbeResponse(root.GetProperty("status").GetString() ?? "", root.TryGetProperty("infocode", out var code) ? code.GetString() : null);
+    }
+
+    internal static async Task<JsonDocument> ReadBoundedJsonAsync(HttpContent content)
+    {
+        if (content.Headers.ContentLength is > MaximumResponseBytes) throw new InvalidDataException("amap_response_too_large");
+        await using var stream = await content.ReadAsStreamAsync();
+        using var buffered = new MemoryStream();
+        var buffer = ArrayPool<byte>.Shared.Rent(4_096);
+        try
+        {
+            var total = 0;
+            while (true)
+            {
+                var read = await stream.ReadAsync(buffer);
+                if (read == 0) break;
+                total += read;
+                if (total > MaximumResponseBytes) throw new InvalidDataException("amap_response_too_large");
+                await buffered.WriteAsync(buffer.AsMemory(0, read));
+            }
+            buffered.Position = 0;
+            return await JsonDocument.ParseAsync(buffered);
+        }
+        finally
+        {
+            Array.Clear(buffer);
+            ArrayPool<byte>.Shared.Return(buffer);
+        }
+    }
+
+    private static void Write(string code, bool success, int realCalls, string? reverseStatus, string? geocodeStatus) =>
+        Console.WriteLine(JsonSerializer.Serialize(new { code, success, real_calls = realCalls, reverse_status = reverseStatus, geocode_status = geocodeStatus }));
+
+    private sealed record ProbeResponse(string Status, string? InfoCode);
+}

supervisor/Dada.Supervisor/OfflineCommandRouter.cs

@@ -84,6 +84,8 @@ internal static class OfflineCommandRouter
                 store.Write(target, value);
                 WriteResult("credential_saved", true);
                 return 0;
+            case "probe" when target == CredentialCatalog.ApiAmap:
+                return AmapProbe.Run(store.Read(target));
             default:
                 return Usage();
         }
@@ -199,7 +201,7 @@ internal static class OfflineCommandRouter
 
     private static int Usage()
     {
-        WriteResult("usage: configure init|data-root|asset-root; secrets set|status|clear; admin-allowlist add|remove|status; doctor; validate-external", false);
+        WriteResult("usage: configure init|data-root|asset-root; secrets set|status|clear|probe; admin-allowlist add|remove|status; doctor; validate-external", false);
         return 2;
     }
 }

tests/api/wp7-04-amap-production-adapter.test.ts

@@ -0,0 +1,47 @@
+import { describe, expect, it, vi } from "vitest";
+
+import { RealAmapAdapter } from "../../apps/api/src/amap-adapter.js";
+import { initializeApiCredentialClients } from "../../apps/api/src/supervisor-channel.js";
+
+describe("TDD-WP7-EXT-003 production Amap adapter", () => {
+  it("uses the fixed HTTPS provider boundary and returns only the formatted location", async () => {
+    const request = vi.fn(async () => ({
+      regeocode: { formatted_address: "模拟省模拟市" },
+      status: "1",
+    }));
+    const adapter = new RealAmapAdapter("fixture-amap-value", { request });
+
+    await expect(adapter.reverseGeocode({ latitude: 12.3456, longitude: 65.4321 })).resolves.toEqual({
+      formattedValue: "模拟省模拟市",
+      serviceMode: "real",
+    });
+    expect(request).toHaveBeenCalledOnce();
+    expect(request.mock.calls[0]?.[0]).toMatchObject({
+      allowRedirects: false,
+      hostname: "restapi.amap.com",
+      maxResponseBytes: 65_536,
+      method: "GET",
+      protocol: "https:",
+      rejectUnauthorized: true,
+      timeoutMs: 15_000,
+    });
+    expect(request.mock.calls[0]?.[0].path).toContain("/v3/geocode/regeo?");
+    expect(request.mock.calls[0]?.[0].path).toContain("location=65.4321%2C12.3456");
+    adapter.dispose();
+    await expect(adapter.reverseGeocode({ latitude: 0, longitude: 0 })).rejects.toThrow("amap_adapter_disposed");
+  });
+
+  it("constructs the real client from the API credential channel and clears the source values", () => {
+    const credentials = {
+      "Dada/P0A/admin/pepper": "fixture-admin-value",
+      "Dada/P0A/api/amap": "fixture-amap-value",
+      "Dada/P0A/api/resend": "fixture-resend-value",
+    };
+
+    const clients = initializeApiCredentialClients(credentials);
+    expect(clients.amap).toBeInstanceOf(RealAmapAdapter);
+    expect(Object.values(credentials)).toEqual(["", "", ""]);
+    clients.amap.dispose();
+    clients.adminAllowlistPepper.fill(0);
+  });
+});

tests/api/wp7-04-amap-release-gate.test.ts

@@ -0,0 +1,85 @@
+import { randomUUID } from "node:crypto";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { afterEach, describe, expect, it } from "vitest";
+
+import { MockAmapAdapter } from "../../apps/api/src/amap-adapter.js";
+import { createApp } from "../../apps/api/src/app.js";
+import { RegistrationService } from "../../apps/api/src/registration.js";
+import { MockResendAdapter } from "../../apps/api/src/resend-adapter.js";
+
+const roots: string[] = [];
+const registrations: RegistrationService[] = [];
+
+afterEach(() => {
+  for (const registration of registrations.splice(0)) registration.close();
+  for (const root of roots.splice(0)) rmSync(root, { force: true, recursive: true });
+});
+
+function createRegistration() {
+  const now = Date.parse("2026-08-04T09:00:00.000Z");
+  const root = mkdtempSync(join(tmpdir(), "dada-wp7-04-amap-"));
+  roots.push(root);
+  const registration = new RegistrationService({
+    challengePepper: Buffer.alloc(32, 0xa1),
+    clock: () => now,
+    currentPrivacyNoticeVersion: "p0a-registration-notice-v1",
+    databasePath: join(root, "dada.sqlite3"),
+    invitePepper: Buffer.alloc(32, 0xa2),
+    resend: new MockResendAdapter(),
+    sessionPepper: Buffer.alloc(32, 0xa3),
+  });
+  registrations.push(registration);
+
+  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 (?, 'Release Gate User', '@release_gate')").run(userId);
+  registration.database.prepare("INSERT INTO credit_accounts (user_id, available_balance, reserved_balance, updated_at) VALUES (?, 10, 0, ?)").run(userId, now);
+  return { registration, session: registration.issueAuthenticatedSession(userId, "user") };
+}
+
+describe("TDD-WP7-EXT-003 Amap release hard stop", () => {
+  it("admits the simulated 1000th request and blocks the 1001st before provider egress", async () => {
+    const { registration, session } = createRegistration();
+    registration.database.prepare(`
+      UPDATE external_service_usage
+      SET used_count = 999, service_status = 'active', pause_reason = NULL
+      WHERE service_id = 'amap_web_service' AND period_type = 'monthly'
+    `).run();
+
+    const amap = new MockAmapAdapter();
+    const app = await createApp({ amap, browserGate: false, networkBoundary: { allowTestPort: true }, registration });
+    const headers = {
+      cookie: `dada_session=${session.sessionToken}`,
+      host: "127.0.0.1:43121",
+      origin: "http://127.0.0.1:43121",
+      "x-csrf-token": registration.issueUserCsrfToken(session.sessionToken),
+    };
+
+    const thousandth = await app.inject({
+      headers,
+      method: "POST",
+      payload: { latitude: 0, longitude: 0 },
+      url: "/api/v1/location/reverse-geocode",
+    });
+    const thousandAndFirst = await app.inject({
+      headers,
+      method: "POST",
+      payload: { latitude: 0, longitude: 0 },
+      url: "/api/v1/location/reverse-geocode",
+    });
+
+    expect(thousandth.statusCode).toBe(200);
+    expect(thousandAndFirst.statusCode).toBe(503);
+    expect(amap.calls).toHaveLength(1);
+    expect(registration.serviceUsage.read("amap_web_service")).toEqual([
+      expect.objectContaining({ hardLimit: 1_000, status: "paused_quota", usedCount: 1_000 }),
+    ]);
+    await app.close();
+  });
+});

tests/package/wp7-03-resend-gate.test.mjs

@@ -0,0 +1,76 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import {
+  validateAuthResult,
+  validateDeliverySummary,
+  validateDomainCheck,
+  validateRedaction,
+} from "../../scripts/lib/resend-release-gate.mjs";
+
+const realEvidence = {
+  source: "human_controlled_real",
+  service: "resend",
+  status: "verified",
+  schema_version: "1.0",
+};
+
+test("requires SPF, DKIM, exact free limits, and no paid fallback", () => {
+  assert.deepEqual(validateDomainCheck({
+    ...realEvidence,
+    dkim: { status: "pass" },
+    domain_controlled: true,
+    free_rules: { daily_limit: 80, monthly_limit: 2400, paid_fallback_enabled: false, status: "verified" },
+    spf: { status: "pass" },
+  }), []);
+  assert.ok(validateDomainCheck({ ...realEvidence, domain_controlled: true, spf: { status: "pass" }, dkim: { status: "fail" }, free_rules: { status: "unknown" } }).includes("dkim"));
+});
+
+test("requires exactly three 20-message delivery cohorts with 19 within 120 seconds", () => {
+  const summary = {
+    ...realEvidence,
+    categories: ["qq", "163", "enterprise"].map((category) => ({
+      category,
+      delivered_within_120_seconds: 19,
+      max_latency_seconds: 120,
+      mock_used: false,
+      preseeded_account_used: false,
+      sent_count: 20,
+    })),
+  };
+  assert.deepEqual(validateDeliverySummary(summary), []);
+  assert.ok(validateDeliverySummary({ ...summary, categories: summary.categories.map((item) => item.category === "163" ? { ...item, delivered_within_120_seconds: 18 } : item) }).some((error) => error.includes("163")));
+  assert.ok(validateDeliverySummary({ ...summary, categories: summary.categories.map((item) => item.category === "enterprise" ? { ...item, max_latency_seconds: undefined } : item) }).some((error) => error.includes("enterprise")));
+});
+
+test("requires formal ordinary and admin authentication chains", () => {
+  assert.deepEqual(validateAuthResult({
+    ...realEvidence,
+    admin: { chain: "formal", status: "passed", verification_code_source: "real_delivery" },
+    mock_used: false,
+    ordinary: { chain: "formal", status: "passed", verification_code_source: "real_delivery" },
+    preseeded_account_used: false,
+  }), []);
+  assert.ok(validateAuthResult({ ...realEvidence, admin: { chain: "mock", status: "passed", verification_code_source: "fixture" }, ordinary: { status: "failed" } }).length > 0);
+});
+
+test("rejects credentials, mailboxes, private values, and paths from evidence", () => {
+  assert.deepEqual(validateRedaction({
+    absolute_paths_in_evidence: false,
+    credentials_in_evidence: false,
+    forbidden_matches: 0,
+    mailboxes_in_evidence: false,
+    private_content_in_evidence: false,
+    schema_version: "1.0",
+    status: "passed",
+  }, JSON.stringify({ category: "qq", delivered_within_120_seconds: 20 })), []);
+  assert.ok(validateRedaction({
+    absolute_paths_in_evidence: false,
+    credentials_in_evidence: false,
+    forbidden_matches: 0,
+    mailboxes_in_evidence: false,
+    private_content_in_evidence: false,
+    schema_version: "1.0",
+    status: "passed",
+  }, JSON.stringify({ mailbox: "recipient@example.invalid" })).includes("email_value"));
+});

tests/package/wp7-05-coverage.test.mjs

@@ -0,0 +1,41 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { buildCoverageEvidence } from '../../scripts/lib/wp7-05-coverage.mjs';
+import { REQUIRED_COVERAGE_UNITS } from '../../scripts/lib/wp7-05-ui-gate.mjs';
+
+const viewports = [
+  { width: 1920, height: 1080, deviceScaleFactor: 1, zoom: 100 },
+  { width: 1920, height: 1080, deviceScaleFactor: 1, zoom: 200 },
+];
+
+function completeUnits() {
+  return REQUIRED_COVERAGE_UNITS.map((page_id) => ({
+    page_id,
+    states: [{
+      state: 'normal',
+      screenshot_100pct: `ui/${page_id}/normal/100pct.png`,
+      screenshot_200pct: `ui/${page_id}/normal/200pct.png`,
+      trace: `ui/${page_id}/normal/trace.zip`,
+    }],
+  }));
+}
+
+test('builds ordered, sanitized evidence for all 22 coverage units', () => {
+  const evidence = buildCoverageEvidence({
+    runId: 'wp7-05-red-001',
+    candidateSha256: 'a'.repeat(64),
+    coverageUnits: completeUnits(),
+    viewports,
+  });
+  assert.equal(evidence.coverage_units.length, 22);
+  assert.equal(evidence.coverage_units[0].page_id, 'support-gate');
+  assert.equal(evidence.candidate_sha256, 'A'.repeat(64));
+});
+
+test('rejects absolute evidence paths and incomplete page state', () => {
+  const units = completeUnits();
+  units[0].states[0].trace = 'C:\\secret\\trace.zip';
+  assert.throws(() => buildCoverageEvidence({
+    runId: 'wp7-05-red-001', candidateSha256: 'a'.repeat(64), coverageUnits: units, viewports,
+  }), /WP7_05_UNSAFE_TRACE/);
+});

tests/package/wp7-05-ui-gate.test.mjs

@@ -0,0 +1,47 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { loadCandidateRecord, validateCoverageEvidence, runWp705Gate, REQUIRED_COVERAGE_UNITS } from '../../scripts/lib/wp7-05-ui-gate.mjs';
+
+test('WP7-05 accepts the WP7-01 candidate record schema', () => {
+  const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'wp7-05-'));
+  const file = path.join(directory, 'release-candidate.json');
+  fs.writeFileSync(file, JSON.stringify({
+    browsers: [
+      { brand: 'Google Chrome', full_version: '150.0.0', major: 150 },
+      { brand: 'Microsoft Edge', full_version: '151.0.0', major: 151 },
+    ],
+    windows: { build: '26200.8875' },
+    candidate_package: { fixed_port: 43121, sha256: 'A'.repeat(64) },
+  }));
+  assert.equal(loadCandidateRecord(file).status, 'ready');
+  fs.rmSync(directory, { recursive: true, force: true });
+});
+
+test('WP7-05 requires all 22 coverage units and both exact candidate viewports', () => {
+  const result = validateCoverageEvidence({ coverage_units: [], viewports: [] });
+  assert.equal(result.status, 'externally_blocked');
+  assert.equal(result.code, 'coverage_units_incomplete');
+  assert.equal(result.missing.length, REQUIRED_COVERAGE_UNITS.length);
+});
+
+test('WP7-05 requires state evidence for every listed coverage unit', () => {
+  const result = validateCoverageEvidence({
+    coverage_units: REQUIRED_COVERAGE_UNITS.map((page_id) => ({ page_id, states: [] })),
+    viewports: [],
+  });
+  assert.equal(result.code, 'coverage_states_incomplete');
+  assert.equal(result.missingStates.length, REQUIRED_COVERAGE_UNITS.length);
+});
+
+test('WP7-05 preserves upstream external blockers instead of declaring Green', () => {
+  const result = runWp705Gate({
+    candidatePath: 'missing-release-candidate.json',
+    evidence: null,
+    dependencies: { 'TASK-WP7-03': 'externally_blocked' },
+  });
+  assert.equal(result.status, 'externally_blocked');
+  assert.equal(result.code, 'candidate_record_missing');
+});

tests/package/wp7-06-prefreeze.test.mjs

@@ -0,0 +1,75 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { buildWp706PrefreezeReport } from "../../scripts/lib/wp7-06-prefreeze.mjs";
+
+const expectedTrace = {
+  errors: [],
+  status: "passed",
+  summary: {
+    acceptanceCriteria: 52,
+    errorCategories: 9,
+    featureModules: 13,
+    parentFamilies: 89,
+    penProductFrames: 18,
+    productContracts: 19,
+    requirements: 109,
+    tasks: 52,
+    testCases: 117,
+    uiPages: 22,
+  },
+};
+
+const upstream = {
+  "TASK-WP7-01": { branch: "codex/wp7-01", head: "1".repeat(40), merged: true, status: "passed" },
+  "TASK-WP7-02": { branch: "codex/wp7-02", head: "2".repeat(40), merged: true, status: "passed" },
+  "TASK-WP7-03": { branch: "codex/wp7-03", head: "3".repeat(40), merged: true, status: "deferred_nonblocking_first_version" },
+  "TASK-WP7-04": { branch: "codex/wp7-04", head: "4".repeat(40), merged: true, status: "deferred_nonblocking_first_version" },
+  "TASK-WP7-05": { branch: "codex/wp7-05", head: "5".repeat(40), merged: true, status: "passed" },
+};
+
+test("builds the exact WP7-06 pre-freeze closure without pretending deferred suppliers passed", () => {
+  const report = buildWp706PrefreezeReport({
+    currentCommit: "a".repeat(40),
+    releaseExists: false,
+    trace: expectedTrace,
+    upstream,
+  });
+
+  assert.equal(report.status, "passed");
+  assert.equal(report.release_json_written, false);
+  assert.deepEqual(report.trace_summary, expectedTrace.summary);
+  assert.deepEqual(report.deferred_external_tasks, ["TASK-WP7-03", "TASK-WP7-04"]);
+});
+
+test("rejects missing lineage and premature RELEASE.json", () => {
+  assert.throws(() => buildWp706PrefreezeReport({
+    currentCommit: "a".repeat(40),
+    releaseExists: false,
+    trace: expectedTrace,
+    upstream: { ...upstream, "TASK-WP7-05": { ...upstream["TASK-WP7-05"], merged: false } },
+  }), /WP7_06_UPSTREAM_NOT_MERGED:TASK-WP7-05/);
+
+  assert.throws(() => buildWp706PrefreezeReport({
+    currentCommit: "a".repeat(40),
+    releaseExists: true,
+    trace: expectedTrace,
+    upstream,
+  }), /WP7_06_RELEASE_WRITTEN_PREMATURELY/);
+});
+
+test("rejects trace drift and unsupported upstream statuses", () => {
+  assert.throws(() => buildWp706PrefreezeReport({
+    currentCommit: "a".repeat(40),
+    releaseExists: false,
+    trace: { ...expectedTrace, summary: { ...expectedTrace.summary, testCases: 116 } },
+    upstream,
+  }), /WP7_06_TRACE_COUNT_MISMATCH:testCases/);
+
+  assert.throws(() => buildWp706PrefreezeReport({
+    currentCommit: "a".repeat(40),
+    releaseExists: false,
+    trace: expectedTrace,
+    upstream: { ...upstream, "TASK-WP7-03": { ...upstream["TASK-WP7-03"], status: "passed" } },
+  }), /WP7_06_UNSUPPORTED_STATUS:TASK-WP7-03/);
+});

tests/package/wp7-07-final-release.test.mjs

@@ -0,0 +1,47 @@
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+
+import { buildFinalReleaseRecord, scanReleaseFiles, validateFinalEvidence } from "../../scripts/lib/wp7-07-final-release.mjs";
+
+function release() {
+  return buildFinalReleaseRecord({
+    appVersion: "0.0.0",
+    browsers: [
+      { brand: "Google Chrome", fullVersion: "150.0.7871.187" },
+      { brand: "Microsoft Edge", fullVersion: "151.0.4129.59" },
+    ],
+    buildCommit: "a".repeat(40),
+    frozenFromCommit: "b".repeat(40),
+    recordedAt: "2026-08-04T06:00:00.000Z",
+    windows: { arch: "x64", build: "26200.8875", displayVersion: "25H2" },
+  });
+}
+
+test("TDD-WP7-REL-001 creates a browser-gate compatible first-version record", () => {
+  const record = release();
+  assert.equal(record.finalRelease, true);
+  assert.equal(record.fixedPort, 43121);
+  assert.deepEqual(record.deferredExternalTasks, ["TASK-WP7-03", "TASK-WP7-04"]);
+  assert.deepEqual(record.browsers.map(({ brand }) => brand).sort(), ["Google Chrome", "Microsoft Edge"]);
+});
+
+test("TDD-WP7-SEC-001 rejects credential shapes and absolute user paths", () => {
+  const root = mkdtempSync(join(tmpdir(), "dada-wp7-07-scan-"));
+  mkdirSync(join(root, "logs"));
+  writeFileSync(join(root, "logs", "diagnostic.txt"), "credential=key-abcdefghijklmnop C:\\Users\\person\\private.txt\n");
+  const scan = scanReleaseFiles({ roots: [root] });
+  assert.equal(scan.status, "failed");
+  assert.deepEqual(new Set(scan.findings.map(({ rule }) => rule)), new Set(["absolute_user_path", "credential_shape"]));
+});
+
+test("TDD-WP7-REL-001 binds release and package hashes only after a zero-finding scan", () => {
+  assert.deepEqual(validateFinalEvidence({
+    packageManifest: { release_status: "first_version_internal", zip_sha256: "C".repeat(64) },
+    release: release(),
+    releaseSha256: "D".repeat(64),
+    scan: { findings: [], status: "passed" },
+  }), { release_sha256: "D".repeat(64), status: "passed", zip_sha256: "C".repeat(64) });
+});