test: strengthen integration oracles and verification (#8295)

* test: strengthen integration oracles and verification

* test: bound lifecycle gates and strengthen workflow checks

* test: verify complete paged and extracted results

* test: preserve bytecode and cancellation evidence

* test: strengthen retained evidence and fixture cleanup

* test: require cross-projection bridge identities

* test: retain fixture owners through cleanup failures

* test: verify graph examples and project selectors

* test: tighten provider and lifecycle regressions

* test: consolidate hex coverage and bound cutter cleanup

* test: bound subprocess output waits and strengthen graph checks

* test: check mcp recovery and preserve cleanup owners

* test: verify structured mcp argument failures

* test: preserve artifact cleanup and gdb limit evidence

* test: preserve evidence identities and bound provider gates

* test: retain browser and comparison cleanup owners

* test: bound startup and strengthen fixture oracles

* test: bound lifecycle gates and verify recovered evidence

* test: verify public outcomes and lifecycle ownership

* test: assert precise evidence and release lifecycle gates

* test: verify selected facts and bound cleanup waits

* test: check retained evidence and decoded records

* test: verify final reports and retain cleanup ownership

* test: bound reviewed startup gates and retain cleanup

* test: verify PE errors and preserve MCP cleanup

* test: preserve MCP fixture cleanup ownership

* test: release provider gates before late startup

tests/acceptance/applications/javascriptGraphQueryCoverage.test.ts

@@ -55,8 +55,46 @@ cliTest(
         parseEvidence(traced.structuredContent).normalized_result,
       );
       expect(trace.summary.total_seed_matches).toBeGreaterThan(0);
-      if (seed.kind === "property")
+      expect(trace.seed).toEqual(seed);
+      expect(trace.seed_node_ids).toHaveLength(
+        trace.summary.total_seed_matches,
+      );
+      const seedNodes = trace.seed_node_ids.map((id) =>
+        trace.nodes.find(({ node_id }) => node_id === id),
+      );
+      if (seed.kind === "event") {
+        expect(seedNodes).toEqual(
+          expect.arrayContaining([
+            expect.objectContaining({
+              kind: "event",
+              properties: expect.objectContaining({ event_name: "" }),
+            }),
+            expect.objectContaining({
+              kind: "listener",
+              properties: expect.objectContaining({ event_name: "" }),
+            }),
+          ]),
+        );
+      } else {
         expect(trace.summary.relevant_unknowns).toBeGreaterThan(0);
+        expect(seedNodes).toContainEqual(
+          expect.objectContaining({
+            kind: "expression",
+            properties: expect.objectContaining({
+              property_path: ["speed"],
+              property_slot_resolution: "unresolved",
+            }),
+          }),
+        );
+        const seedUnknown = trace.unknowns.find(
+          ({ node_id }) =>
+            node_id !== null && trace.seed_node_ids.includes(node_id),
+        );
+        expect(seedUnknown).toMatchObject({
+          family: "object-flow",
+          reason: "ambiguous-target",
+        });
+      }
     }
   },
 );