test(e2e): strengthen fast coverage for live contracts

scripts/checks/e2e-mock-parity.mts

@@ -8,11 +8,14 @@ import { fileURLToPath } from "node:url";
 
 import ts from "typescript";
 
+import { moduleTagDeclarations } from "../../tools/e2e/module-tags.mts";
+
 const REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
 export const DEFAULT_PARITY_MANIFEST = "test/e2e/mock-parity.json";
 
 export type MockParityEntry = {
   live: string;
+  liveSources?: string[];
   fast?: string[];
   liveOnlyReason?: string;
 };
@@ -23,6 +26,7 @@ export type MockParityManifest = {
 };
 
 const LIVE_TEST = /^test\/e2e\/live\/.+\.test\.ts$/u;
+const LIVE_HELPER = /^test\/e2e\/live\/(?!.*\.test\.ts$).+\.ts$/u;
 const FAST_TESTS = [
   /^src\/.+\.test\.ts$/u,
   /^nemoclaw\/src\/.+\.test\.ts$/u,
@@ -50,7 +54,10 @@ function sourceTokens(source: string): string {
     for (const child of children) visit(child);
   };
   visit(sourceFile);
-  return JSON.stringify(tokens);
+  return JSON.stringify({
+    moduleTags: moduleTagDeclarations(source).map(({ tag }) => tag),
+    tokens,
+  });
 }
 
 export function isMockParityRelevantSourceChange(
@@ -91,6 +98,7 @@ export function validateMockParity(options: {
   }
 
   const entries = new Map<string, MockParityEntry>();
+  const sourceOwners = new Map<string, MockParityEntry[]>();
   for (const entry of manifest.entries) {
     if (!entry || typeof entry !== "object" || typeof entry.live !== "string") {
       errors.push("mock parity entries must be objects with a live path");
@@ -106,6 +114,14 @@ export function validateMockParity(options: {
     }
     entries.set(entry.live, entry);
 
+    if (
+      entry.liveSources !== undefined &&
+      (!Array.isArray(entry.liveSources) ||
+        entry.liveSources.some((file) => typeof file !== "string"))
+    ) {
+      errors.push(`${entry.live}: liveSources must be an array of live E2E helper paths`);
+      continue;
+    }
     if (
       entry.fast !== undefined &&
       (!Array.isArray(entry.fast) || entry.fast.some((file) => typeof file !== "string"))
@@ -126,6 +142,18 @@ export function validateMockParity(options: {
     }
 
     if (!fileExists(entry.live)) errors.push(`${entry.live}: live test does not exist`);
+    for (const sourceFile of new Set(entry.liveSources ?? [])) {
+      if (!isSafeRepoPath(sourceFile) || !LIVE_HELPER.test(sourceFile)) {
+        errors.push(`${entry.live}: ${sourceFile} is not a test/e2e/live/**/*.ts helper file`);
+        continue;
+      }
+      if (!fileExists(sourceFile)) {
+        errors.push(`${entry.live}: live E2E helper does not exist: ${sourceFile}`);
+      }
+      const owners = sourceOwners.get(sourceFile) ?? [];
+      owners.push(entry);
+      sourceOwners.set(sourceFile, owners);
+    }
     for (const fastFile of new Set(fast)) {
       if (!isFastPrTest(fastFile)) {
         errors.push(`${entry.live}: ${fastFile} is not collected by a fast PR test project`);
@@ -135,10 +163,41 @@ export function validateMockParity(options: {
     }
   }
 
-  for (const liveFile of [...new Set(changedFiles)].filter((file) => LIVE_TEST.test(file))) {
-    if (!entries.has(liveFile)) {
+  const changedFileSet = new Set(changedFiles);
+  const requireChangedFastTest = (entry: MockParityEntry, changedSource: string): void => {
+    const mappedFastTests = Array.isArray(entry.fast)
+      ? entry.fast.filter((fastFile): fastFile is string => typeof fastFile === "string")
+      : [];
+    if (
+      mappedFastTests.length > 0 &&
+      !mappedFastTests.some((fastFile) => changedFileSet.has(fastFile))
+    ) {
+      errors.push(
+        changedSource === entry.live
+          ? `${entry.live}: change at least one mapped fast PR test with the live E2E`
+          : `${changedSource}: change at least one fast PR test mapped from ${entry.live}`,
+      );
+    }
+  };
+
+  for (const liveFile of [...changedFileSet].filter((file) => LIVE_TEST.test(file))) {
+    const entry = entries.get(liveFile);
+    if (!entry) {
       errors.push(`${liveFile}: changed live E2E needs an entry in ${DEFAULT_PARITY_MANIFEST}`);
+      continue;
+    }
+    requireChangedFastTest(entry, liveFile);
+  }
+
+  for (const helperFile of [...changedFileSet].filter((file) => LIVE_HELPER.test(file))) {
+    const owners = sourceOwners.get(helperFile) ?? [];
+    if (owners.length === 0) {
+      errors.push(
+        `${helperFile}: changed live E2E helper needs an owning entry in ${DEFAULT_PARITY_MANIFEST}`,
+      );
+      continue;
     }
+    for (const owner of owners) requireChangedFastTest(owner, helperFile);
   }
 
   return errors.sort();
@@ -161,6 +220,18 @@ function sourceAtRef(ref: string, file: string): string | null {
   }
 }
 
+/** Remove metadata-only live and fast test changes before parity validation. */
+export function filterMockParityRelevantChangedFiles(
+  files: readonly string[],
+  sourceAtBase: (file: string) => string | null,
+  sourceAtHead: (file: string) => string | null,
+): string[] {
+  return files.filter((file) => {
+    if (!LIVE_TEST.test(file) && !LIVE_HELPER.test(file) && !isFastPrTest(file)) return true;
+    return isMockParityRelevantSourceChange(sourceAtBase(file), sourceAtHead(file));
+  });
+}
+
 function changedFiles(base: string, head: string): string[] {
   const files = execFileSync(
     "git",
@@ -172,10 +243,10 @@ function changedFiles(base: string, head: string): string[] {
   )
     .split(/\r?\n/u)
     .filter(Boolean);
-  return files.filter(
-    (file) =>
-      !LIVE_TEST.test(file) ||
-      isMockParityRelevantSourceChange(sourceAtRef(base, file), sourceAtRef(head, file)),
+  return filterMockParityRelevantChangedFiles(
+    files,
+    (file) => sourceAtRef(base, file),
+    (file) => sourceAtRef(head, file),
   );
 }
 

src/lib/actions/sandbox/policy-channel.ts

@@ -151,7 +151,7 @@ function withSandboxMutationLockUnlessPreview<T>(
  * Internal composition dependencies for channel mutation.
  *
  * The Google Chat capability is intentionally absent from the public CLI
- * composition. The live E2E entrypoint supplies it directly so environment
+ * composition. The channels stop/start live E2E helper supplies it directly so environment
  * variables and predictable sandbox names cannot enable non-interactive
  * audience enrollment in ordinary production execution.
  */